diff --git a/src/app/drive/components/NameCollisionDialog/NameCollisionContainer.tsx b/src/app/drive/components/NameCollisionDialog/NameCollisionContainer.tsx
index f20ebff415..d919461527 100644
--- a/src/app/drive/components/NameCollisionDialog/NameCollisionContainer.tsx
+++ b/src/app/drive/components/NameCollisionDialog/NameCollisionContainer.tsx
@@ -1,26 +1,13 @@
 import { FC, useMemo } from 'react';
 import NameCollisionDialog, { OnSubmitPressed } from '.';
-import { moveItemsToTrash } from 'views/Trash/services';
 import { RootState } from 'app/store';
 import { useAppDispatch, useAppSelector } from 'app/store/hooks';
-import { storageActions } from 'app/store/slices/storage';
-import storageThunks from 'app/store/slices/storage/storage.thunks';
-import { fetchSortedFolderContentThunk } from 'app/store/slices/storage/storage.thunks/fetchSortedFolderContentThunk';
 import { uiActions } from 'app/store/slices/ui';
-import { DriveItemData } from 'app/drive/types';
 import { IRoot } from 'app/store/slices/storage/types';
 import workspacesSelectors from 'app/store/slices/workspaces/workspaces.selectors';
-import { uploadFoldersWithTracking } from 'app/drive/services/folder.service/uploadFoldersWithTracking';
-import replaceFileService from 'views/Drive/services/replaceFile.service';
-import { Network, getEnvironmentConfig } from 'app/drive/services/network.service';
-import { fileVersionsActions, fileVersionsSelectors } from 'app/store/slices/fileVersions';
-import { isVersioningExtensionAllowed } from 'views/Drive/components/VersionHistory/utils';
-import { checkFolderDuplicated } from 'app/store/slices/storage/folderUtils/checkFolderDuplicated';
-import { getUniqueFolderName } from 'app/store/slices/storage/folderUtils/getUniqueFolderName';
-import { getUniqueFilename } from 'app/store/slices/storage/fileUtils/getUniqueFilename';
-import { checkDuplicatedFiles } from 'app/store/slices/storage/fileUtils/checkDuplicatedFiles';
-import { CollisionGroup } from 'app/store/slices/storage/storage.model';
-import { MoveItemPayload } from 'app/store/slices/storage/storage.thunks/moveItemsThunk';
+import { fileVersionsSelectors } from 'app/store/slices/fileVersions';
+import { NameCollisionContext, resolveCollision } from './nameCollision.actions';
+import { findExistingItemFor, findPendingGroupIndex, getRemainingGroups } from './nameCollision.utils';
 
 const NameCollisionContainer: FC = () => {
   const dispatch = useAppDispatch();
@@ -31,149 +18,82 @@ const NameCollisionContainer: FC = () => {
   const operationType = collisionDialogInfo?.operation;
   const newItems = useMemo(() => collisionGroups.flatMap((g) => g.duplicatedItems), [collisionGroups]);
   const existingItems = useMemo(() => collisionGroups.flatMap((g) => g.existingItems), [collisionGroups]);
+  const remainingItemsCount = newItems.length;
 
   const selectedWorkspace = useAppSelector(workspacesSelectors.getSelectedWorkspace);
   const limits = useAppSelector(fileVersionsSelectors.getLimits);
   const maxUploadFileSize = useAppSelector(fileVersionsSelectors.getMaxFileSizeLimit);
   const isVersioningEnabled = limits?.versioning?.enabled ?? false;
+  const versioningMaxFileSize = limits?.versioning?.maxFileSize ?? 0;
+
+  const context: NameCollisionContext = {
+    dispatch,
+    selectedWorkspace,
+    maxUploadFileSize,
+    isVersioningEnabled,
+    versioningMaxFileSize,
+  };
 
   const closeDialog = () => {
     dispatch(uiActions.setIsNameCollisionDialogOpen({ open: false, info: undefined }));
   };
 
-  const replaceAndMoveItem = async (group: CollisionGroup) => {
-    await moveItemsToTrash(group.existingItems);
-    await dispatch(
-      storageThunks.moveItemsThunk({
-        items: group.duplicatedItems as DriveItemData[],
-        destinationFolderId: group.destinationUuid,
-      }),
-    );
-  };
-
-  const keepAndMoveItem = async (group: CollisionGroup) => {
-    for (const item of group.duplicatedItems as DriveItemData[]) {
-      let itemParsed: MoveItemPayload;
-
-      if (item.isFolder) {
-        const { duplicatedFoldersResponse } = await checkFolderDuplicated([item], group.destinationUuid);
-        const finalName = await getUniqueFolderName(
-          item.plainName ?? item.name,
-          duplicatedFoldersResponse as DriveItemData[],
-          group.destinationUuid,
-        );
-        itemParsed = { ...item, name: finalName, plain_name: finalName, newItemName: finalName };
-      } else {
-        const { duplicatedFilesResponse } = await checkDuplicatedFiles([item], group.destinationUuid);
-        const finalName = await getUniqueFilename(item.name, item.type, duplicatedFilesResponse, group.destinationUuid);
-        itemParsed = { ...item, name: finalName, plainName: finalName, plain_name: finalName, newItemName: finalName };
-      }
-
-      await dispatch(
-        storageThunks.moveItemsThunk({
-          items: [itemParsed],
-          destinationFolderId: group.destinationUuid,
-        }),
+  const triggerSelectedOptionsOnSubmit = async ({ operationType, operation, applyToAll }: OnSubmitPressed) => {
+    if (applyToAll) {
+      closeDialog();
+      await Promise.all(
+        collisionGroups.map((group) =>
+          resolveCollision(
+            {
+              operationType,
+              operation,
+              items: group.duplicatedItems,
+              existingItems: group.existingItems,
+              destinationUuid: group.destinationUuid,
+            },
+            context,
+          ),
+        ),
       );
+      return;
     }
-  };
-
-  const uploadFileAndGetFileId = async (file: File, itemToReplace: DriveItemData) => {
-    const { bridgeUser, bridgePass, encryptionKey, bucketId } = await getEnvironmentConfig(!!selectedWorkspace);
-    const network = new Network(bridgeUser, bridgePass, encryptionKey);
-    const taskId = `replace-${itemToReplace.uuid}-${Date.now()}`;
-    const [uploadPromise] = network.uploadFile(
-      bucketId,
-      { filecontent: file, filesize: file.size, progressCallback: () => {} },
-      { taskId },
-    );
-    return uploadPromise;
-  };
 
-  const replaceFileVersion = async (file: File, itemToReplace: DriveItemData) => {
-    const newFileId = await uploadFileAndGetFileId(file, itemToReplace);
-    await replaceFileService.replaceFile(itemToReplace.uuid, { fileId: newFileId, size: file.size });
-    dispatch(fileVersionsActions.invalidateCache(itemToReplace.uuid));
-  };
-
-  const replaceAndUploadItem = async (group: CollisionGroup) => {
-    const itemsToUpload = group.duplicatedItems as (IRoot | File)[];
-    const itemsToReplace = group.existingItems;
-
-    for (let i = 0; i < itemsToUpload.length; i++) {
-      const itemToUpload = itemsToUpload[i];
-      const itemToReplace = itemsToReplace[i];
-
-      if ((itemToUpload as IRoot).fullPathEdited) {
-        await moveItemsToTrash([itemToReplace]);
-        await uploadFoldersWithTracking({
-          payload: [{ root: { ...(itemToUpload as IRoot) }, currentFolderId: group.destinationUuid }],
-          selectedWorkspace,
-          dispatch,
-          maxUploadFileSize,
-        });
-      } else {
-        const file = itemToUpload as File;
-        const canReplaceVersion = isVersioningEnabled && isVersioningExtensionAllowed(itemToReplace);
-        if (canReplaceVersion) {
-          await replaceFileVersion(file, itemToReplace);
-        } else {
-          await moveItemsToTrash([itemToReplace]);
-          await dispatch(
-            storageThunks.uploadItemsThunk({
-              files: [file],
-              parentFolderId: group.destinationUuid,
-              options: { disableDuplicatedNamesCheck: true },
-            }),
-          );
-        }
-      }
-
-      dispatch(fetchSortedFolderContentThunk(group.destinationUuid));
+    const groupIndex = findPendingGroupIndex(collisionGroups);
+    const hasPendingGroup = groupIndex !== -1;
+    if (!hasPendingGroup) {
+      closeDialog();
+      return;
     }
-  };
 
-  const keepAndUploadItem = async (group: CollisionGroup) => {
-    for (const itemToUpload of group.duplicatedItems as (IRoot | File)[]) {
-      if ((itemToUpload as IRoot).fullPathEdited) {
-        await uploadFoldersWithTracking({
-          payload: [{ root: { ...(itemToUpload as IRoot) }, currentFolderId: group.destinationUuid }],
-          selectedWorkspace,
-          dispatch,
-          maxUploadFileSize,
-        });
-      } else {
-        await dispatch(
-          storageThunks.uploadItemsThunk({
-            files: [itemToUpload as File],
-            parentFolderId: group.destinationUuid,
-          }),
-        );
-      }
-      dispatch(fetchSortedFolderContentThunk(group.destinationUuid));
-    }
-  };
+    const group = collisionGroups[groupIndex];
+    const itemToUpload = group.duplicatedItems[0];
+    const collidingExistingItem = findExistingItemFor(itemToUpload, group.existingItems);
+    const isReplacing = operation === 'replace';
+    const replacedExistingItem = isReplacing ? collidingExistingItem : undefined;
+
+    await resolveCollision(
+      {
+        operationType,
+        operation,
+        items: [itemToUpload],
+        existingItems: group.existingItems,
+        destinationUuid: group.destinationUuid,
+      },
+      context,
+    );
 
-  const triggerSelectedOptionsOnSubmit = async ({ operationType, operation }: OnSubmitPressed) => {
-    for (const group of collisionGroups) {
-      switch (operationType + operation) {
-        case 'move' + 'keep':
-          await keepAndMoveItem(group);
-          dispatch(storageActions.popItemsToDelete(group.duplicatedItems as DriveItemData[]));
-          break;
-        case 'move' + 'replace':
-          await replaceAndMoveItem(group);
-          dispatch(storageActions.popItemsToDelete(group.duplicatedItems as DriveItemData[]));
-          break;
-        case 'upload' + 'keep':
-          await keepAndUploadItem(group);
-          break;
-        case 'upload' + 'replace':
-          await replaceAndUploadItem(group);
-          break;
-      }
+    const remainingGroups = getRemainingGroups(collisionGroups, groupIndex, replacedExistingItem);
+    const hasRemainingGroups = remainingGroups.length > 0;
+    if (hasRemainingGroups) {
+      dispatch(
+        uiActions.setIsNameCollisionDialogOpen({
+          open: true,
+          info: { groups: remainingGroups, operation: operationType },
+        }),
+      );
+    } else {
+      closeDialog();
     }
-    closeDialog();
   };
 
   if (!collisionDialogInfo) return null;
@@ -187,6 +107,7 @@ const NameCollisionContainer: FC = () => {
       onSubmitButtonPressed={triggerSelectedOptionsOnSubmit}
       onCloseDialog={closeDialog}
       operationType={operationType as 'move' | 'upload'}
+      remainingItemsCount={remainingItemsCount}
     />
   );
 };
diff --git a/src/app/drive/components/NameCollisionDialog/index.tsx b/src/app/drive/components/NameCollisionDialog/index.tsx
index 7db0c245bb..f6419a0d9d 100644
--- a/src/app/drive/components/NameCollisionDialog/index.tsx
+++ b/src/app/drive/components/NameCollisionDialog/index.tsx
@@ -1,7 +1,7 @@
 import { FC, useEffect, useMemo, useState } from 'react';
 import { Label, Radio, RadioGroup } from '@headlessui/react';
 
-import { Button, Modal } from '@internxt/ui';
+import { Button, Checkbox, Modal } from '@internxt/ui';
 import { DriveItemData } from 'app/drive/types';
 import { useTranslationContext } from 'app/i18n/provider/TranslationProvider';
 import { IRoot } from 'app/store/slices/storage/types';
@@ -13,9 +13,10 @@ export const OPERATION_TYPE = {
 
 export type OnSubmitPressed = {
   operationType: 'move' | 'upload';
-  operation: 'keep' | 'replace';
+  operation: 'keep' | 'replace' | 'skip';
   itemsToUpload: (File | IRoot | DriveItemData)[];
   itemsToReplace: (DriveItemData | IRoot)[];
+  applyToAll: boolean;
 };
 
 export interface NameCollisionDialogProps {
@@ -23,9 +24,16 @@ export interface NameCollisionDialogProps {
   isOpen: boolean;
   driveItems: (DriveItemData | IRoot)[];
   newItems: (File | IRoot)[];
+  remainingItemsCount: number;
   onCloseDialog(): void;
   onCancelButtonPressed(): void;
-  onSubmitButtonPressed({ operationType, operation, itemsToUpload, itemsToReplace }: OnSubmitPressed): Promise<void>;
+  onSubmitButtonPressed({
+    operationType,
+    operation,
+    itemsToUpload,
+    itemsToReplace,
+    applyToAll,
+  }: OnSubmitPressed): Promise<void>;
 }
 
 const NameCollisionDialog: FC<NameCollisionDialogProps> = ({
@@ -33,35 +41,41 @@ const NameCollisionDialog: FC<NameCollisionDialogProps> = ({
   operationType,
   newItems,
   driveItems,
+  remainingItemsCount,
   onCancelButtonPressed,
   onCloseDialog,
   onSubmitButtonPressed,
 }: NameCollisionDialogProps) => {
   const { translate } = useTranslationContext();
-  const options = [
-    {
-      operation: 'replace' as const,
-      name: translate('modals.renameModal.replaceItem'),
-    },
-    {
-      operation: 'keep' as const,
-      name: translate('modals.renameModal.keepBoth'),
-    },
-  ];
+  const options = useMemo(
+    () => [
+      {
+        operation: 'replace' as const,
+        name: translate('modals.alreadyExistsModal.replaceItem'),
+      },
+      {
+        operation: 'keep' as const,
+        name: translate('modals.alreadyExistsModal.keepBoth'),
+      },
+      {
+        operation: 'skip' as const,
+        name: translate('modals.alreadyExistsModal.skipItem'),
+      },
+    ],
+    [translate],
+  );
   const [isLoading, setIsLoading] = useState(false);
   const [selectedOption, setSelectedOption] = useState(options[0]);
+  const [applyToAll, setApplyToAll] = useState(false);
+
+  const title = translate('modals.alreadyExistsModal.title');
+  const description = translate('modals.alreadyExistsModal.description', { itemName: newItems?.[0]?.name });
 
-  const title =
-    newItems?.length > 1 ? translate('modals.renameModal.titleMultipleItems') : translate('modals.renameModal.title');
-  const description =
-    newItems?.length > 1
-      ? translate('modals.renameModal.multipleDescription')
-      : translate('modals.renameModal.description', { itemName: newItems?.[0]?.name });
   const primaryButtonText = useMemo(
     () =>
       operationType === OPERATION_TYPE.MOVE
-        ? translate('modals.renameModal.move')
-        : translate('modals.renameModal.upload'),
+        ? translate('modals.alreadyExistsModal.move')
+        : translate('modals.alreadyExistsModal.upload'),
     [operationType],
   );
 
@@ -69,13 +83,15 @@ const NameCollisionDialog: FC<NameCollisionDialogProps> = ({
     if (isOpen) {
       setIsLoading(false);
       setSelectedOption(options[0]);
+      setApplyToAll(false);
     }
-  }, [isOpen]);
+  }, [isOpen, options]);
 
   const onClose = (): void => {
     onCloseDialog();
     onCancelButtonPressed();
     setSelectedOption(options[0]);
+    setApplyToAll(false);
     setIsLoading(false);
   };
 
@@ -88,9 +104,10 @@ const NameCollisionDialog: FC<NameCollisionDialogProps> = ({
       operation: selectedOption.operation,
       itemsToUpload: newItems,
       itemsToReplace: driveItems,
+      applyToAll,
     });
 
-    onClose();
+    setIsLoading(false);
   };
 
   return (
@@ -100,7 +117,7 @@ const NameCollisionDialog: FC<NameCollisionDialogProps> = ({
         <p className="text-base text-gray-80">{description}</p>
 
         <RadioGroup value={selectedOption} onChange={setSelectedOption} disabled={isLoading}>
-          <Label className="sr-only">{translate('modals.renameModal.selectOption')}</Label>
+          <Label className="sr-only">{translate('modals.alreadyExistsModal.selectOption')}</Label>
           <div className="flex flex-col items-start space-y-3">
             {options.map((option) => (
               <Radio value={option} className="rounded-md outline-none" key={option.operation}>
@@ -109,12 +126,14 @@ const NameCollisionDialog: FC<NameCollisionDialogProps> = ({
                     className={`flex h-5 w-5 flex-col items-center justify-center rounded-full ${
                       option.operation === selectedOption.operation
                         ? 'bg-primary active:bg-primary-dark'
-                        : 'border border-gray-40 bg-white group-hover:border-gray-50'
+                        : 'border border-gray-40 bg-white dark:bg-transparent group-hover:border-gray-50'
                     }`}
                   >
                     <div
                       className={`h-2.5 w-2.5 rounded-full ${
-                        option.operation === selectedOption.operation ? 'bg-white' : 'bg-white group-hover:bg-gray-5'
+                        option.operation === selectedOption.operation
+                          ? 'bg-white'
+                          : 'bg-white dark:bg-transparent group-hover:bg-gray-5'
                       }`}
                     />
                   </div>
@@ -128,6 +147,17 @@ const NameCollisionDialog: FC<NameCollisionDialogProps> = ({
           </div>
         </RadioGroup>
 
+        {remainingItemsCount > 1 && (
+          <div className="flex items-center">
+            <Checkbox id="apply-to-all" checked={applyToAll} onClick={() => setApplyToAll((prev) => !prev)} />
+            <label
+              htmlFor="apply-to-all"
+              className="ml-2 cursor-pointer select-none text-base font-medium text-gray-80"
+            >
+              {translate('modals.alreadyExistsModal.applyToAll')}
+            </label>
+          </div>
+        )}
         <div className="flex flex-row items-center justify-end space-x-2">
           <Button disabled={isLoading} variant="secondary" onClick={onClose}>
             {translate('actions.cancel')}
diff --git a/src/app/drive/components/NameCollisionDialog/nameCollision.actions.test.ts b/src/app/drive/components/NameCollisionDialog/nameCollision.actions.test.ts
new file mode 100644
index 0000000000..8de192cd67
--- /dev/null
+++ b/src/app/drive/components/NameCollisionDialog/nameCollision.actions.test.ts
@@ -0,0 +1,610 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { getDriveItemData } from 'testUtils/fixtures/drive.fixtures';
+import { DriveItemData } from 'app/drive/types';
+import { IRoot } from 'app/store/slices/storage/types';
+import { NameCollisionContext, ResolveCollisionParams, resolveCollision } from './nameCollision.actions';
+
+const mocks = vi.hoisted(() => ({
+  dispatch: vi.fn(),
+  moveItemsToTrash: vi.fn(),
+  moveItemsThunk: vi.fn(),
+  uploadItemsThunk: vi.fn(),
+  fetchSortedFolderContentThunk: vi.fn(),
+  popItemsToDelete: vi.fn(),
+  invalidateCache: vi.fn(),
+  checkDuplicatedFiles: vi.fn(),
+  getUniqueFilename: vi.fn(),
+  checkFolderDuplicated: vi.fn(),
+  getUniqueFolderName: vi.fn(),
+  uploadFoldersWithTracking: vi.fn(),
+  getEnvironmentConfig: vi.fn(),
+  networkUploadFile: vi.fn(),
+  replaceFile: vi.fn(),
+  handleRepeatedUploadingFiles: vi.fn(),
+  handleRepeatedUploadingFolders: vi.fn(),
+}));
+
+vi.mock('views/Trash/services', () => ({ moveItemsToTrash: mocks.moveItemsToTrash }));
+vi.mock('app/store/slices/storage/storage.thunks', () => ({
+  default: { moveItemsThunk: mocks.moveItemsThunk, uploadItemsThunk: mocks.uploadItemsThunk },
+}));
+vi.mock('app/store/slices/storage/storage.thunks/fetchSortedFolderContentThunk', () => ({
+  fetchSortedFolderContentThunk: mocks.fetchSortedFolderContentThunk,
+}));
+vi.mock('app/store/slices/storage', () => ({ storageActions: { popItemsToDelete: mocks.popItemsToDelete } }));
+vi.mock('app/store/slices/fileVersions', () => ({ fileVersionsActions: { invalidateCache: mocks.invalidateCache } }));
+vi.mock('app/store/slices/storage/fileUtils/checkDuplicatedFiles', () => ({
+  checkDuplicatedFiles: mocks.checkDuplicatedFiles,
+}));
+vi.mock('app/store/slices/storage/fileUtils/getUniqueFilename', () => ({ getUniqueFilename: mocks.getUniqueFilename }));
+vi.mock('app/store/slices/storage/folderUtils/checkFolderDuplicated', () => ({
+  checkFolderDuplicated: mocks.checkFolderDuplicated,
+}));
+vi.mock('app/store/slices/storage/folderUtils/getUniqueFolderName', () => ({
+  getUniqueFolderName: mocks.getUniqueFolderName,
+}));
+vi.mock('app/store/slices/storage/storage.thunks/renameItemsThunk', () => ({
+  handleRepeatedUploadingFiles: mocks.handleRepeatedUploadingFiles,
+  handleRepeatedUploadingFolders: mocks.handleRepeatedUploadingFolders,
+}));
+vi.mock('app/drive/services/folder.service/uploadFoldersWithTracking', () => ({
+  uploadFoldersWithTracking: mocks.uploadFoldersWithTracking,
+}));
+vi.mock('app/drive/services/network.service', () => ({
+  getEnvironmentConfig: mocks.getEnvironmentConfig,
+  Network: class {
+    uploadFile = mocks.networkUploadFile;
+  },
+}));
+vi.mock('views/Drive/services/replaceFile.service', () => ({ default: { replaceFile: mocks.replaceFile } }));
+vi.mock('views/Drive/components/VersionHistory/utils', () => ({
+  isVersioningExtensionAllowed: (item?: { type?: string }) => item?.type === 'pdf',
+}));
+
+const DESTINATION = 'destination-uuid';
+const VERSIONING_MAX_FILE_SIZE = 10;
+
+const asMoveAction = (payload: unknown) => ({ type: 'move', payload });
+const asPopAction = (payload: unknown) => ({ type: 'pop', payload });
+const asUploadAction = (payload: unknown) => ({ type: 'upload', payload });
+const asRefreshAction = (payload: unknown) => ({ type: 'refresh', payload });
+const asInvalidateCacheAction = (payload: unknown) => ({ type: 'invalidateCache', payload });
+
+const getRoot = (name = 'Photos', children: Partial<Pick<IRoot, 'childrenFiles' | 'childrenFolders'>> = {}): IRoot => ({
+  name,
+  folderId: null,
+  childrenFiles: [],
+  childrenFolders: [],
+  fullPathEdited: `/${name}`,
+  ...children,
+});
+
+const getContext = (overrides: Partial<NameCollisionContext> = {}): NameCollisionContext => ({
+  dispatch: mocks.dispatch as unknown as NameCollisionContext['dispatch'],
+  selectedWorkspace: null,
+  maxUploadFileSize: 5000,
+  isVersioningEnabled: false,
+  versioningMaxFileSize: VERSIONING_MAX_FILE_SIZE,
+  ...overrides,
+});
+
+const asRenamed = (item: DriveItemData, name: string) => {
+  const renamedItem = { ...item, name, plain_name: name, newItemName: name };
+  return item.isFolder ? renamedItem : { ...renamedItem, plainName: name };
+};
+
+const expectMovesThenPop = (movedPayloads: unknown[], poppedItems: DriveItemData[]) =>
+  expect(mocks.dispatch.mock.calls).toEqual([
+    ...movedPayloads.map((payload) => [asMoveAction({ items: [payload], destinationFolderId: DESTINATION })]),
+    [asPopAction(poppedItems)],
+  ]);
+
+const getNextFreeName = (name: string, takenItems: unknown[]) => `${name} (${takenItems.length})`;
+const getNextFreeFolderName = async (name: string, takenItems: unknown[]) => getNextFreeName(name, takenItems);
+const getNextFreeFilename = async (name: string, _type: string, takenItems: unknown[]) =>
+  getNextFreeName(name, takenItems);
+
+const findSameUniqueFilenameTwice = () =>
+  mocks.getUniqueFilename
+    .mockResolvedValueOnce('report (2)')
+    .mockResolvedValueOnce('report (2)')
+    .mockResolvedValueOnce('report (3)');
+
+/**
+ * Keeps the lookup of `heldName` pending until the lookup of another name starts, and returns the
+ * order in which the lookups start and end.
+ */
+const holdFilenameLookupUntilOthersStart = (heldName: string): string[] => {
+  const lookupOrder: string[] = [];
+  let releaseHeldLookup = () => {};
+  const untilOtherLookupStarts = new Promise<void>((release) => {
+    releaseHeldLookup = release;
+  });
+
+  mocks.getUniqueFilename.mockImplementation(async (name: string) => {
+    lookupOrder.push(`start ${name}`);
+    if (name === heldName) {
+      await untilOtherLookupStarts;
+    } else {
+      releaseHeldLookup();
+    }
+    lookupOrder.push(`end ${name}`);
+    return `${name} (1)`;
+  });
+
+  return lookupOrder;
+};
+
+const failMovesOf = (failingItems: DriveItemData[]) =>
+  mocks.dispatch.mockImplementation((action?: { payload?: { items?: DriveItemData[] } }) => ({
+    unwrap: async () => {
+      const hasFailingItem = action?.payload?.items?.some((item) => failingItems.includes(item));
+      if (hasFailingItem) throw new Error('move failed');
+    },
+  }));
+
+const succeedAllMoves = () => failMovesOf([]);
+
+const getPdfCollision = (name: string, size: number) => ({
+  file: new File(['x'.repeat(size)], `${name}.pdf`),
+  existing: getDriveItemData({ uuid: `existing-${name}`, plainName: name, type: 'pdf' }),
+});
+
+const resolve = (params: Omit<ResolveCollisionParams, 'destinationUuid'>, context = getContext()) =>
+  resolveCollision({ ...params, destinationUuid: DESTINATION }, context);
+
+const replaceWithVersioning = (collisions: ReturnType<typeof getPdfCollision>[]) =>
+  resolve(
+    {
+      operationType: 'upload',
+      operation: 'replace',
+      items: collisions.map(({ file }) => file),
+      existingItems: collisions.map(({ existing }) => existing),
+    },
+    getContext({ isVersioningEnabled: true }),
+  );
+
+/**
+ * Mocks are reset by hand because the browser test project does not do it between tests.
+ */
+beforeEach(() => {
+  vi.resetAllMocks();
+  succeedAllMoves();
+  mocks.checkDuplicatedFiles.mockResolvedValue({ duplicatedFilesResponse: ['file-dup'] });
+  mocks.getUniqueFilename.mockResolvedValue('report (1)');
+  mocks.checkFolderDuplicated.mockResolvedValue({ duplicatedFoldersResponse: ['folder-dup'] });
+  mocks.getUniqueFolderName.mockResolvedValue('Photos (1)');
+  mocks.moveItemsThunk.mockImplementation(asMoveAction);
+  mocks.popItemsToDelete.mockImplementation(asPopAction);
+  mocks.uploadItemsThunk.mockImplementation(asUploadAction);
+  mocks.fetchSortedFolderContentThunk.mockImplementation(asRefreshAction);
+  mocks.invalidateCache.mockImplementation(asInvalidateCacheAction);
+  mocks.getEnvironmentConfig.mockResolvedValue({ bridgeUser: 'u', bridgePass: 'p', encryptionKey: 'k', bucketId: 'b' });
+  mocks.networkUploadFile.mockReturnValue([Promise.resolve('new-file-id'), undefined]);
+});
+
+describe('resolveCollision', () => {
+  test.each<[ResolveCollisionParams['operationType'], ResolveCollisionParams['operation'], unknown[][]]>([
+    ['move', 'skip', []],
+    ['upload', 'skip', []],
+    ['move', 'keep', [[asPopAction([])]]],
+    ['move', 'replace', [[asPopAction([])]]],
+    ['upload', 'keep', []],
+    ['upload', 'replace', []],
+  ])(
+    'when %s + %s has nothing to resolve, then nothing is moved, trashed or uploaded',
+    async (operationType, operation, expectedDispatchCalls) => {
+      const items = operation === 'skip' ? [getDriveItemData()] : [];
+
+      await resolve({ operationType, operation, items, existingItems: [] });
+
+      expect(mocks.moveItemsToTrash).not.toHaveBeenCalled();
+      expect(mocks.uploadFoldersWithTracking).not.toHaveBeenCalled();
+      expect(mocks.dispatch.mock.calls).toEqual(expectedDispatchCalls);
+    },
+  );
+
+  test('when moving with keep, then items get a unique name and leave the pending deletion list', async () => {
+    const file = getDriveItemData({ plainName: 'report', name: 'report', type: 'pdf', isFolder: false });
+    const folder = getDriveItemData({ plainName: 'Photos', name: 'Photos', isFolder: true });
+
+    await resolve({ operationType: 'move', operation: 'keep', items: [file, folder], existingItems: [] });
+
+    expect(mocks.getUniqueFilename).toHaveBeenCalledWith('report', 'pdf', ['file-dup'], DESTINATION);
+    expect(mocks.getUniqueFolderName).toHaveBeenCalledWith('Photos', ['folder-dup'], DESTINATION);
+    expect(mocks.moveItemsToTrash).not.toHaveBeenCalled();
+    expectMovesThenPop([asRenamed(file, 'report (1)'), asRenamed(folder, 'Photos (1)')], [file, folder]);
+  });
+
+  test('when two moved files share name and extension and the user keeps both, then they are moved under different unique names', async () => {
+    const first = getDriveItemData({ uuid: 'first', plainName: 'report', name: 'report', type: 'pdf' });
+    const second = getDriveItemData({ uuid: 'second', plainName: 'report', name: 'report', type: 'pdf' });
+    mocks.getUniqueFilename.mockImplementation(getNextFreeFilename);
+
+    await resolve({ operationType: 'move', operation: 'keep', items: [first, second], existingItems: [] });
+
+    expectMovesThenPop([asRenamed(first, 'report (1)'), asRenamed(second, 'report (2)')], [first, second]);
+  });
+
+  test('when two moved folders share a name and the user keeps both, then they are moved under different unique names', async () => {
+    const first = getDriveItemData({ uuid: 'first', plainName: 'Photos', name: 'Photos', isFolder: true });
+    const second = getDriveItemData({ uuid: 'second', plainName: 'Photos', name: 'Photos', isFolder: true });
+    const file = getDriveItemData({ uuid: 'file', plainName: 'Photos', name: 'Photos', type: 'pdf' });
+    mocks.getUniqueFilename.mockImplementation(getNextFreeFilename);
+    mocks.getUniqueFolderName.mockImplementation(getNextFreeFolderName);
+
+    await resolve({ operationType: 'move', operation: 'keep', items: [first, file, second], existingItems: [] });
+
+    expectMovesThenPop(
+      [asRenamed(first, 'Photos (1)'), asRenamed(second, 'Photos (2)'), asRenamed(file, 'Photos (1)')],
+      [first, second, file],
+    );
+  });
+
+  test('when the unique name found for a kept file was already given to another kept file, then a new name is looked for among the names already given', async () => {
+    const first = getDriveItemData({ uuid: 'first', plainName: 'report', name: 'report', type: 'pdf' });
+    const second = getDriveItemData({ uuid: 'second', plainName: 'report', name: 'report', type: 'pdf' });
+    const firstRenamed = expect.objectContaining({ uuid: 'first', plainName: 'report (2)' });
+    findSameUniqueFilenameTwice();
+
+    await resolve({ operationType: 'move', operation: 'keep', items: [first, second], existingItems: [] });
+
+    expect(mocks.getUniqueFilename).toHaveBeenLastCalledWith(
+      'report (2)',
+      'pdf',
+      ['file-dup', firstRenamed],
+      DESTINATION,
+    );
+    expectMovesThenPop([asRenamed(first, 'report (2)'), asRenamed(second, 'report (3)')], [first, second]);
+  });
+
+  test('when two kept files whose names only differ in the number at the end are given the same unique name, then the second one gets a new name', async () => {
+    const first = getDriveItemData({ uuid: 'first', plainName: 'report', name: 'report', type: 'pdf' });
+    const second = getDriveItemData({ uuid: 'second', plainName: 'report (1)', name: 'report (1)', type: 'pdf' });
+    findSameUniqueFilenameTwice();
+
+    await resolve({ operationType: 'move', operation: 'keep', items: [first, second], existingItems: [] });
+
+    expectMovesThenPop([asRenamed(first, 'report (2)'), asRenamed(second, 'report (3)')], [first, second]);
+  });
+
+  test('when kept items have different names, then their unique names are looked up in parallel', async () => {
+    const report = getDriveItemData({ uuid: 'report', plainName: 'report', name: 'report', type: 'pdf' });
+    const other = getDriveItemData({ uuid: 'other', plainName: 'other', name: 'other', type: 'pdf' });
+    const lookupOrder = holdFilenameLookupUntilOthersStart('report');
+
+    await resolve({ operationType: 'move', operation: 'keep', items: [report, other], existingItems: [] });
+
+    expect(lookupOrder).toEqual(['start report', 'start other', 'end other', 'end report']);
+  });
+
+  test('when one move fails, then only the successfully moved items are removed from the items to delete', async () => {
+    const moved = getDriveItemData({ uuid: 'moved', plainName: 'report', type: 'pdf' });
+    const failed = getDriveItemData({ uuid: 'failed', plainName: 'other', type: 'pdf' });
+    const existingItems = [
+      getDriveItemData({ uuid: 'existing-report', plainName: 'report', type: 'pdf' }),
+      getDriveItemData({ uuid: 'existing-other', plainName: 'other', type: 'pdf' }),
+    ];
+    failMovesOf([failed]);
+
+    await resolve({ operationType: 'move', operation: 'replace', items: [moved, failed], existingItems });
+
+    expectMovesThenPop([moved, failed], [moved]);
+  });
+
+  test('when two moved files collide with the same existing file and the user replaces, then the existing file is trashed once, the first item is moved with its own name and the second is moved with a unique name', async () => {
+    const first = getDriveItemData({ uuid: 'first', plainName: 'report', name: 'report', type: 'pdf' });
+    const second = getDriveItemData({ uuid: 'second', plainName: 'report', name: 'report', type: 'pdf' });
+    const other = getDriveItemData({ uuid: 'other', plainName: 'other', name: 'other', type: 'pdf' });
+    const existing = getDriveItemData({ uuid: 'existing', plainName: 'report', type: 'pdf' });
+    const existingOther = getDriveItemData({ uuid: 'existing-other', plainName: 'other', type: 'pdf' });
+    const callOrder: string[] = [];
+    mocks.moveItemsThunk.mockImplementation((payload: { items: DriveItemData[] }) => {
+      callOrder.push(`move ${payload.items[0].uuid}`);
+      return asMoveAction(payload);
+    });
+    mocks.getUniqueFilename.mockImplementation(async () => {
+      callOrder.push('rename');
+      return 'report (1)';
+    });
+
+    await resolve({
+      operationType: 'move',
+      operation: 'replace',
+      items: [first, second, other],
+      existingItems: [existing, existingOther],
+    });
+
+    expect(mocks.moveItemsToTrash).toHaveBeenCalledTimes(1);
+    expect(mocks.moveItemsToTrash).toHaveBeenCalledWith([existing, existingOther]);
+    expect(callOrder).toEqual(['move first', 'move other', 'rename', 'move second']);
+    expectMovesThenPop([first, other, asRenamed(second, 'report (1)')], [first, other, second]);
+  });
+
+  test('when moving with replace, then matched existing items are trashed first and unmatched items are moved under a unique name', async () => {
+    const matched = getDriveItemData({ uuid: 'matched', plainName: 'report', type: 'pdf' });
+    const unmatched = getDriveItemData({ uuid: 'unmatched', plainName: 'other', type: 'pdf' });
+    const existing = getDriveItemData({ uuid: 'existing', plainName: 'report', type: 'pdf' });
+    const callOrder: string[] = [];
+    mocks.moveItemsToTrash.mockImplementation(async () => callOrder.push('trash'));
+    mocks.moveItemsThunk.mockImplementation((payload: unknown) => {
+      callOrder.push('move');
+      return asMoveAction(payload);
+    });
+    mocks.getUniqueFilename.mockResolvedValue('other (1)');
+
+    await resolve({
+      operationType: 'move',
+      operation: 'replace',
+      items: [matched, unmatched],
+      existingItems: [existing],
+    });
+
+    expect(mocks.moveItemsToTrash).toHaveBeenCalledWith([existing]);
+    expect(callOrder).toEqual(['trash', 'move', 'move']);
+    expectMovesThenPop([matched, asRenamed(unmatched, 'other (1)')], [matched, unmatched]);
+  });
+
+  test('when a moved file has no existing file left to replace and the user replaces, then nothing is trashed and the file is moved under a unique name', async () => {
+    const file = getDriveItemData({ uuid: 'file', plainName: 'report', name: 'report', type: 'pdf' });
+
+    await resolve({ operationType: 'move', operation: 'replace', items: [file], existingItems: [] });
+
+    expect(mocks.moveItemsToTrash).not.toHaveBeenCalled();
+    expectMovesThenPop([asRenamed(file, 'report (1)')], [file]);
+  });
+
+  test('when uploading with keep, then folders upload with tracking, files upload under a unique name without the duplicates check, and the folder is refreshed', async () => {
+    const context = getContext({ maxUploadFileSize: 123, selectedWorkspace: { id: 'ws' } as never });
+    const file = new File(['content'], 'report.pdf');
+    const root = getRoot();
+
+    await resolve({ operationType: 'upload', operation: 'keep', items: [file, root], existingItems: [] }, context);
+
+    expect(mocks.uploadFoldersWithTracking).toHaveBeenCalledWith({
+      payload: [{ root: { ...root }, currentFolderId: DESTINATION }],
+      selectedWorkspace: { id: 'ws' },
+      dispatch: context.dispatch,
+      maxUploadFileSize: 123,
+    });
+    expect(mocks.dispatch.mock.calls).toEqual([
+      [
+        asUploadAction({
+          files: [expect.objectContaining({ name: 'report (1).pdf' })],
+          parentFolderId: DESTINATION,
+          options: { disableDuplicatedNamesCheck: true },
+        }),
+      ],
+      [asRefreshAction(DESTINATION)],
+    ]);
+    expect(mocks.popItemsToDelete).not.toHaveBeenCalled();
+  });
+
+  test('when three colliding files of the same series are uploaded with keep, then they upload together under the next free names', async () => {
+    const fileNames = ['file.txt', 'file (1).txt', 'file (2).txt'];
+    mocks.getUniqueFilename
+      .mockResolvedValueOnce('file (3)')
+      .mockResolvedValueOnce('file (4)')
+      .mockResolvedValueOnce('file (5)');
+
+    await resolve({
+      operationType: 'upload',
+      operation: 'keep',
+      items: fileNames.map((name) => new File(['content'], name)),
+      existingItems: [],
+    });
+
+    expect(mocks.dispatch.mock.calls).toEqual([
+      [
+        asUploadAction({
+          files: ['file (3).txt', 'file (4).txt', 'file (5).txt'].map((name) => expect.objectContaining({ name })),
+          parentFolderId: DESTINATION,
+          options: { disableDuplicatedNamesCheck: true },
+        }),
+      ],
+      [asRefreshAction(DESTINATION)],
+    ]);
+  });
+
+  test('when uploading with replace and versioning is off, then only matched existing items are trashed and re-uploaded without the duplicates check', async () => {
+    const matched = new File(['content'], 'report.pdf');
+    const unmatched = new File(['content'], 'other.txt');
+    const existing = getDriveItemData({ uuid: 'existing', plainName: 'report', type: 'pdf' });
+
+    await resolve({
+      operationType: 'upload',
+      operation: 'replace',
+      items: [matched, unmatched],
+      existingItems: [existing],
+    });
+
+    expect(mocks.moveItemsToTrash).toHaveBeenCalledWith([existing]);
+    expect(mocks.uploadFoldersWithTracking).not.toHaveBeenCalled();
+    expect(mocks.networkUploadFile).not.toHaveBeenCalled();
+    expect(mocks.dispatch.mock.calls).toEqual([
+      [
+        asUploadAction({
+          files: [matched],
+          parentFolderId: DESTINATION,
+          options: { disableDuplicatedNamesCheck: true },
+        }),
+      ],
+      [asRefreshAction(DESTINATION)],
+    ]);
+  });
+
+  test('when uploading with replace and versioning is on, then allowed extensions become a new version while folders and other files are trashed and re-uploaded', async () => {
+    const context = getContext({ isVersioningEnabled: true, selectedWorkspace: { id: 'ws' } as never });
+    const pdf = new File(['content'], 'report.pdf');
+    const image = new File(['content'], 'photo.png');
+    const root = getRoot();
+    const existingPdf = getDriveItemData({ uuid: 'existing-pdf', plainName: 'report', type: 'pdf' });
+    const existingImage = getDriveItemData({ uuid: 'existing-png', plainName: 'photo', type: 'png' });
+    const existingFolder = getDriveItemData({
+      uuid: 'existing-folder',
+      plainName: 'Photos',
+      isFolder: true,
+      type: 'pdf',
+    });
+
+    await resolve(
+      {
+        operationType: 'upload',
+        operation: 'replace',
+        items: [pdf, image, root],
+        existingItems: [existingPdf, existingImage, existingFolder],
+      },
+      context,
+    );
+
+    expect(mocks.moveItemsToTrash).toHaveBeenCalledWith([existingImage, existingFolder]);
+    expect(mocks.uploadFoldersWithTracking).toHaveBeenCalledWith(
+      expect.objectContaining({ payload: [{ root: { ...root }, currentFolderId: DESTINATION }] }),
+    );
+    expect(mocks.getEnvironmentConfig).toHaveBeenCalledWith(true);
+    expect(mocks.networkUploadFile).toHaveBeenCalledWith(
+      'b',
+      expect.objectContaining({ filecontent: pdf, filesize: pdf.size }),
+      { taskId: expect.stringMatching(/^replace-existing-pdf-\d+$/) },
+    );
+    expect(mocks.replaceFile).toHaveBeenCalledWith('existing-pdf', { fileId: 'new-file-id', size: pdf.size });
+    expect(mocks.dispatch.mock.calls).toEqual([
+      [asUploadAction(expect.objectContaining({ files: [image], options: { disableDuplicatedNamesCheck: true } }))],
+      [asInvalidateCacheAction('existing-pdf')],
+      [asRefreshAction(DESTINATION)],
+    ]);
+  });
+
+  test('when uploading with skip, then skipped files are ignored and skipped folders merge their new content into the existing folder recursively', async () => {
+    const existingFile = new File(['a'], 'a.txt');
+    const newFile = new File(['b'], 'b.txt');
+    const nestedFile = new File(['c'], 'c.txt');
+    const collidingSubfolder = getRoot('Sub', { childrenFiles: [nestedFile] });
+    const newSubfolder = getRoot('New');
+    const root = getRoot('Photos', {
+      childrenFiles: [existingFile, newFile],
+      childrenFolders: [collidingSubfolder, newSubfolder],
+    });
+    const existingPdf = getDriveItemData({ uuid: 'existing-pdf', plainName: 'report', type: 'pdf' });
+    const existingFolder = getDriveItemData({ uuid: 'photos-uuid', plainName: 'Photos', isFolder: true });
+    mocks.handleRepeatedUploadingFiles.mockImplementation(async (files: File[]) => ({
+      unrepeatedItems: files.filter((file) => file !== existingFile),
+      repeatedItems: [],
+      existingItems: [],
+    }));
+    mocks.handleRepeatedUploadingFolders.mockImplementation(async (folders: IRoot[]) => ({
+      unrepeatedItems: folders.filter((folder) => folder !== collidingSubfolder),
+      repeatedItems: folders.filter((folder) => folder === collidingSubfolder),
+      existingItems: folders.includes(collidingSubfolder) ? [{ uuid: 'sub-uuid', plainName: 'Sub' }] : [],
+    }));
+
+    await resolve({
+      operationType: 'upload',
+      operation: 'skip',
+      items: [new File(['content'], 'report.pdf'), root],
+      existingItems: [existingPdf, existingFolder],
+    });
+
+    expect(mocks.moveItemsToTrash).not.toHaveBeenCalled();
+    expect(mocks.uploadFoldersWithTracking).toHaveBeenCalledTimes(1);
+    expect(mocks.uploadFoldersWithTracking).toHaveBeenCalledWith(
+      expect.objectContaining({ payload: [{ root: { ...newSubfolder }, currentFolderId: 'photos-uuid' }] }),
+    );
+    expect(mocks.dispatch.mock.calls).toEqual([
+      [
+        asUploadAction({
+          files: [newFile],
+          parentFolderId: 'photos-uuid',
+          options: { disableDuplicatedNamesCheck: true },
+        }),
+      ],
+      [
+        asUploadAction({
+          files: [nestedFile],
+          parentFolderId: 'sub-uuid',
+          options: { disableDuplicatedNamesCheck: true },
+        }),
+      ],
+      [asRefreshAction(DESTINATION)],
+    ]);
+  });
+
+  test('when several files are versioned, then they are replaced one at a time', async () => {
+    let inFlight = 0;
+    let maxInFlight = 0;
+    mocks.replaceFile.mockImplementation(async () => {
+      inFlight += 1;
+      maxInFlight = Math.max(maxInFlight, inFlight);
+      await Promise.resolve();
+      inFlight -= 1;
+    });
+
+    await resolve(
+      {
+        operationType: 'upload',
+        operation: 'replace',
+        items: [new File(['a'], 'a.pdf'), new File(['b'], 'b.pdf')],
+        existingItems: [
+          getDriveItemData({ uuid: 'a', plainName: 'a', type: 'pdf' }),
+          getDriveItemData({ uuid: 'b', plainName: 'b', type: 'pdf' }),
+        ],
+      },
+      getContext({ isVersioningEnabled: true }),
+    );
+
+    expect(mocks.replaceFile).toHaveBeenCalledTimes(2);
+    expect(maxInFlight).toBe(1);
+    expect(mocks.moveItemsToTrash).not.toHaveBeenCalled();
+    expect(mocks.dispatch.mock.calls).toEqual([
+      [asInvalidateCacheAction('a')],
+      [asInvalidateCacheAction('b')],
+      [asRefreshAction(DESTINATION)],
+    ]);
+  });
+
+  test.each([
+    ['under', VERSIONING_MAX_FILE_SIZE - 1],
+    ['exactly at', VERSIONING_MAX_FILE_SIZE],
+  ])(
+    'when replacing a versionable file %s the versioning size limit, then it becomes a new version and nothing is trashed',
+    async (_, size) => {
+      const { file, existing } = getPdfCollision('report', size);
+
+      await replaceWithVersioning([{ file, existing }]);
+
+      expect(mocks.replaceFile).toHaveBeenCalledWith(existing.uuid, { fileId: 'new-file-id', size });
+      expect(mocks.moveItemsToTrash).not.toHaveBeenCalled();
+      expect(mocks.uploadItemsThunk).not.toHaveBeenCalled();
+    },
+  );
+
+  test('when replacing a versionable file over the versioning size limit, then the existing file is trashed and the new one is uploaded', async () => {
+    const { file, existing } = getPdfCollision('report', VERSIONING_MAX_FILE_SIZE + 1);
+
+    await replaceWithVersioning([{ file, existing }]);
+
+    expect(mocks.replaceFile).not.toHaveBeenCalled();
+    expect(mocks.networkUploadFile).not.toHaveBeenCalled();
+    expect(mocks.moveItemsToTrash).toHaveBeenCalledWith([existing]);
+    expect(mocks.uploadItemsThunk).toHaveBeenCalledWith({
+      files: [file],
+      parentFolderId: DESTINATION,
+      options: { disableDuplicatedNamesCheck: true },
+    });
+  });
+
+  test('when replacing versionable files of mixed sizes at once, then only the ones within the limit become new versions', async () => {
+    const small = getPdfCollision('small', VERSIONING_MAX_FILE_SIZE);
+    const big = getPdfCollision('big', VERSIONING_MAX_FILE_SIZE + 1);
+
+    await replaceWithVersioning([small, big]);
+
+    expect(mocks.replaceFile).toHaveBeenCalledTimes(1);
+    expect(mocks.replaceFile).toHaveBeenCalledWith(small.existing.uuid, {
+      fileId: 'new-file-id',
+      size: small.file.size,
+    });
+    expect(mocks.moveItemsToTrash).toHaveBeenCalledWith([big.existing]);
+    expect(mocks.uploadItemsThunk).toHaveBeenCalledWith(expect.objectContaining({ files: [big.file] }));
+  });
+});
diff --git a/src/app/drive/components/NameCollisionDialog/nameCollision.actions.ts b/src/app/drive/components/NameCollisionDialog/nameCollision.actions.ts
new file mode 100644
index 0000000000..e480151d03
--- /dev/null
+++ b/src/app/drive/components/NameCollisionDialog/nameCollision.actions.ts
@@ -0,0 +1,486 @@
+import { items as itemUtils } from '@internxt/lib';
+import { WorkspaceData } from '@internxt/sdk/dist/workspaces';
+import { renameFile } from 'app/crypto/services/utils';
+import { uploadFoldersWithTracking } from 'app/drive/services/folder.service/uploadFoldersWithTracking';
+import { Network, getEnvironmentConfig } from 'app/drive/services/network.service';
+import { DriveItemData } from 'app/drive/types';
+import { AppDispatch } from 'app/store';
+import { fileVersionsActions } from 'app/store/slices/fileVersions';
+import { storageActions } from 'app/store/slices/storage';
+import { checkDuplicatedFiles } from 'app/store/slices/storage/fileUtils/checkDuplicatedFiles';
+import { getUniqueFilename } from 'app/store/slices/storage/fileUtils/getUniqueFilename';
+import { checkFolderDuplicated } from 'app/store/slices/storage/folderUtils/checkFolderDuplicated';
+import { getUniqueFolderName } from 'app/store/slices/storage/folderUtils/getUniqueFolderName';
+import storageThunks from 'app/store/slices/storage/storage.thunks';
+import { fetchSortedFolderContentThunk } from 'app/store/slices/storage/storage.thunks/fetchSortedFolderContentThunk';
+import { MoveItemPayload } from 'app/store/slices/storage/storage.thunks/moveItemsThunk';
+import {
+  handleRepeatedUploadingFiles,
+  handleRepeatedUploadingFolders,
+} from 'app/store/slices/storage/storage.thunks/renameItemsThunk';
+import { IRoot } from 'app/store/slices/storage/types';
+import { isVersioningExtensionAllowed } from 'views/Drive/components/VersionHistory/utils';
+import replaceFileService from 'views/Drive/services/replaceFile.service';
+import { moveItemsToTrash } from 'views/Trash/services';
+import {
+  CollisionItem,
+  CollisionPair,
+  getCollisionPairs,
+  getUnpairedItems,
+  groupByNameSeries,
+  isFolderUpload,
+  isNameTakenBy,
+  splitReplacingPairs,
+} from './nameCollision.utils';
+
+export type CollisionOperationType = 'move' | 'upload';
+export type CollisionOperation = 'keep' | 'replace' | 'skip';
+
+export interface NameCollisionContext {
+  dispatch: AppDispatch;
+  selectedWorkspace: WorkspaceData | null;
+  maxUploadFileSize: number;
+  isVersioningEnabled: boolean;
+  versioningMaxFileSize: number;
+}
+
+export interface ResolveCollisionParams {
+  operationType: CollisionOperationType;
+  operation: CollisionOperation;
+  items: CollisionItem[];
+  existingItems: DriveItemData[];
+  destinationUuid: string;
+}
+
+type ResolveMoveCollisionParams = Omit<ResolveCollisionParams, 'operationType' | 'items'> & { items: DriveItemData[] };
+type ResolveUploadCollisionParams = Omit<ResolveCollisionParams, 'operationType' | 'items'> & {
+  items: (IRoot | File)[];
+};
+
+interface ItemMove {
+  item: DriveItemData;
+  payload: MoveItemPayload;
+}
+
+interface UniquelyNamedItem {
+  item: DriveItemData;
+  uniqueName: string;
+}
+
+const getDestinationDuplicates = async (item: DriveItemData, destinationUuid: string): Promise<DriveItemData[]> => {
+  if (item.isFolder) {
+    const { duplicatedFoldersResponse } = await checkFolderDuplicated([item], destinationUuid);
+    return duplicatedFoldersResponse as DriveItemData[];
+  }
+
+  const { duplicatedFilesResponse } = await checkDuplicatedFiles([item], destinationUuid);
+  return duplicatedFilesResponse as DriveItemData[];
+};
+
+const getLookupName = (item: DriveItemData): string => (item.isFolder ? (item.plainName ?? item.name) : item.name);
+
+const getNextUniqueName = (
+  item: DriveItemData,
+  name: string,
+  takenItems: DriveItemData[],
+  destinationUuid: string,
+): Promise<string> => {
+  if (item.isFolder) {
+    return getUniqueFolderName(name, takenItems, destinationUuid);
+  }
+
+  return getUniqueFilename(name, item.type, takenItems, destinationUuid);
+};
+
+/**
+ * Re-checks the names already assigned in this batch after every attempt, because the server knows
+ * nothing about names that are assigned but not moved yet.
+ */
+const getUniqueNameInBatch = async (
+  item: DriveItemData,
+  destinationUuid: string,
+  renamedItems: DriveItemData[],
+): Promise<string> => {
+  const destinationDuplicates = await getDestinationDuplicates(item, destinationUuid);
+  const takenItems = [...destinationDuplicates, ...renamedItems];
+  let uniqueName = getLookupName(item);
+
+  do {
+    uniqueName = await getNextUniqueName(item, uniqueName, takenItems, destinationUuid);
+  } while (isNameTakenBy(uniqueName, item, renamedItems));
+
+  return uniqueName;
+};
+
+const getRenamedMovePayload = (item: DriveItemData, newName: string): MoveItemPayload => {
+  const renamedItem = { ...item, name: newName, plain_name: newName, newItemName: newName };
+  return item.isFolder ? renamedItem : { ...renamedItem, plainName: newName };
+};
+
+const getSeriesUniqueNames = async (
+  seriesItems: DriveItemData[],
+  destinationUuid: string,
+): Promise<UniquelyNamedItem[]> => {
+  const renamedItems: DriveItemData[] = [];
+  const namedItems: UniquelyNamedItem[] = [];
+
+  for (const item of seriesItems) {
+    const uniqueName = await getUniqueNameInBatch(item, destinationUuid, renamedItems);
+    renamedItems.push({ ...item, name: uniqueName, plainName: uniqueName });
+    namedItems.push({ item, uniqueName });
+  }
+
+  return namedItems;
+};
+
+const getUniqueNames = async (items: DriveItemData[], destinationUuid: string): Promise<UniquelyNamedItem[]> => {
+  const series = groupByNameSeries(items, getLookupName);
+  const namesBySeries = await Promise.all(
+    series.map((seriesItems) => getSeriesUniqueNames(seriesItems, destinationUuid)),
+  );
+
+  return namesBySeries.flat();
+};
+
+const getUniqueNameMoves = async (items: DriveItemData[], destinationUuid: string): Promise<ItemMove[]> => {
+  const namedItems = await getUniqueNames(items, destinationUuid);
+  return namedItems.map(({ item, uniqueName }) => ({ item, payload: getRenamedMovePayload(item, uniqueName) }));
+};
+
+const moveItem = async (
+  payload: MoveItemPayload,
+  destinationUuid: string,
+  { dispatch }: NameCollisionContext,
+): Promise<boolean> => {
+  try {
+    await dispatch(storageThunks.moveItemsThunk({ items: [payload], destinationFolderId: destinationUuid })).unwrap();
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Moves every item on its own, because the move thunk settles once for the whole batch and would
+ * hide which items made it to the destination when one of them fails.
+ */
+const moveItems = async (
+  moves: ItemMove[],
+  destinationUuid: string,
+  context: NameCollisionContext,
+): Promise<DriveItemData[]> => {
+  const isMovedByIndex = await Promise.all(moves.map(({ payload }) => moveItem(payload, destinationUuid, context)));
+  const succeededMoves = moves.filter((_, index) => isMovedByIndex[index]);
+
+  return succeededMoves.map(({ item }) => item);
+};
+
+/**
+ * Moves the items to the destination under a name that does not collide with anything there.
+ */
+const keepAndMoveItems = async (
+  items: DriveItemData[],
+  destinationUuid: string,
+  context: NameCollisionContext,
+): Promise<DriveItemData[]> => {
+  if (items.length === 0) return [];
+
+  const moves = await getUniqueNameMoves(items, destinationUuid);
+  return moveItems(moves, destinationUuid, context);
+};
+
+/**
+ * Trashes the colliding drive items and then moves the incoming ones into their place.
+ */
+const trashAndMoveItems = async (
+  replacingPairs: CollisionPair<DriveItemData>[],
+  destinationUuid: string,
+  context: NameCollisionContext,
+): Promise<DriveItemData[]> => {
+  if (replacingPairs.length === 0) return [];
+
+  const replacingMoves: ItemMove[] = replacingPairs.map(({ item }) => ({ item, payload: item }));
+
+  await moveItemsToTrash(replacingPairs.map((pair) => pair.existing));
+  return moveItems(replacingMoves, destinationUuid, context);
+};
+
+const replaceAndMoveItems = async (
+  items: DriveItemData[],
+  existingItems: DriveItemData[],
+  destinationUuid: string,
+  context: NameCollisionContext,
+): Promise<DriveItemData[]> => {
+  const pairs = getCollisionPairs(items, existingItems);
+  const unpairedItems = getUnpairedItems(items, existingItems);
+  const { replacingPairs, leftoverItems } = splitReplacingPairs(pairs);
+  const itemsToKeep = [...leftoverItems, ...unpairedItems];
+
+  const replacingItems = await trashAndMoveItems(replacingPairs, destinationUuid, context);
+  const keptItems = await keepAndMoveItems(itemsToKeep, destinationUuid, context);
+
+  return [...replacingItems, ...keptItems];
+};
+
+/**
+ * Applies the chosen resolution to items that collide while being moved, then removes them
+ * from the pending-deletion list once moved. Skipped items are left untouched.
+ */
+const resolveMoveCollision = async (
+  { operation, items, existingItems, destinationUuid }: ResolveMoveCollisionParams,
+  context: NameCollisionContext,
+) => {
+  if (operation === 'skip') return;
+
+  let movedItems: DriveItemData[];
+
+  if (operation === 'keep') {
+    movedItems = await keepAndMoveItems(items, destinationUuid, context);
+  } else {
+    movedItems = await replaceAndMoveItems(items, existingItems, destinationUuid, context);
+  }
+  context.dispatch(storageActions.popItemsToDelete(movedItems));
+};
+
+const uploadFileAndGetFileId = async (
+  file: File,
+  itemToReplace: DriveItemData,
+  { selectedWorkspace }: NameCollisionContext,
+): Promise<string> => {
+  const { bridgeUser, bridgePass, encryptionKey, bucketId } = await getEnvironmentConfig(!!selectedWorkspace);
+  const network = new Network(bridgeUser, bridgePass, encryptionKey);
+  const taskId = `replace-${itemToReplace.uuid}-${Date.now()}`;
+  const [uploadPromise] = network.uploadFile(
+    bucketId,
+    { filecontent: file, filesize: file.size, progressCallback: () => {} },
+    { taskId },
+  );
+  return uploadPromise;
+};
+
+const replaceFileVersion = async (file: File, itemToReplace: DriveItemData, context: NameCollisionContext) => {
+  const newFileId = await uploadFileAndGetFileId(file, itemToReplace, context);
+  await replaceFileService.replaceFile(itemToReplace.uuid, { fileId: newFileId, size: file.size });
+  context.dispatch(fileVersionsActions.invalidateCache(itemToReplace.uuid));
+};
+
+const uploadFiles = async (
+  files: File[],
+  destinationUuid: string,
+  { dispatch }: NameCollisionContext,
+  shouldSkipDuplicatesCheck = false,
+) => {
+  if (files.length === 0) return;
+
+  await dispatch(
+    storageThunks.uploadItemsThunk({
+      files,
+      parentFolderId: destinationUuid,
+      options: { disableDuplicatedNamesCheck: shouldSkipDuplicatesCheck },
+    }),
+  );
+};
+
+const uploadFolders = async (
+  folders: IRoot[],
+  destinationUuid: string,
+  { dispatch, selectedWorkspace, maxUploadFileSize }: NameCollisionContext,
+) => {
+  if (folders.length === 0) return;
+
+  await uploadFoldersWithTracking({
+    payload: folders.map((root) => ({ root: { ...root }, currentFolderId: destinationUuid })),
+    selectedWorkspace,
+    dispatch,
+    maxUploadFileSize,
+  });
+};
+
+const splitFoldersAndFiles = (items: (IRoot | File)[]) => ({
+  folders: items.filter(isFolderUpload),
+  files: items.filter((item): item is File => !isFolderUpload(item)),
+});
+
+const uploadItems = async (
+  items: (IRoot | File)[],
+  destinationUuid: string,
+  context: NameCollisionContext,
+  shouldSkipDuplicatesCheck = false,
+) => {
+  const { folders, files } = splitFoldersAndFiles(items);
+
+  await uploadFolders(folders, destinationUuid, context);
+  await uploadFiles(files, destinationUuid, context, shouldSkipDuplicatesCheck);
+};
+
+const isVersionedFilePair = (
+  pair: CollisionPair<IRoot | File>,
+  { isVersioningEnabled, versioningMaxFileSize }: NameCollisionContext,
+) =>
+  !isFolderUpload(pair.item) &&
+  isVersioningEnabled &&
+  isVersioningExtensionAllowed(pair.existing) &&
+  pair.item.size <= versioningMaxFileSize;
+
+/**
+ * Versioned files are replaced one at a time because that upload bypasses the upload queue.
+ */
+const replaceFileVersions = async (pairs: CollisionPair<IRoot | File>[], context: NameCollisionContext) => {
+  for (const pair of pairs) {
+    await replaceFileVersion(pair.item as File, pair.existing, context);
+  }
+};
+
+const trashAndUploadItems = async (
+  pairs: CollisionPair<IRoot | File>[],
+  destinationUuid: string,
+  context: NameCollisionContext,
+) => {
+  if (pairs.length === 0) return;
+
+  await moveItemsToTrash(pairs.map((pair) => pair.existing));
+  await uploadItems(
+    pairs.map((pair) => pair.item),
+    destinationUuid,
+    context,
+    true,
+  );
+};
+
+/**
+ * Replaces the colliding drive items with the uploaded ones. Files whose extension supports
+ * versioning and whose size is within the versioning limit become a new version of the existing
+ * file; everything else is trashed and re-uploaded.
+ */
+const replaceAndUploadItems = async (
+  pairs: CollisionPair<IRoot | File>[],
+  destinationUuid: string,
+  context: NameCollisionContext,
+): Promise<void> => {
+  if (pairs.length === 0) return;
+
+  await trashAndUploadItems(
+    pairs.filter((pair) => !isVersionedFilePair(pair, context)),
+    destinationUuid,
+    context,
+  );
+  await replaceFileVersions(
+    pairs.filter((pair) => isVersionedFilePair(pair, context)),
+    context,
+  );
+
+  await context.dispatch(fetchSortedFolderContentThunk(destinationUuid));
+};
+
+const uploadNewFilesOnly = async (files: File[], destinationUuid: string, context: NameCollisionContext) => {
+  const { unrepeatedItems: newFiles } = await handleRepeatedUploadingFiles(files, destinationUuid);
+  await uploadFiles(newFiles as File[], destinationUuid, context, true);
+};
+
+/**
+ * Merges a skipped folder upload into its existing counterpart: files that already
+ * exist are left untouched, new files and new subfolders are uploaded into the
+ * existing folder, and colliding subfolders are merged recursively so the folder
+ * structure is preserved.
+ */
+const mergeSkipFolderUpload = async (root: IRoot, existingFolderUuid: string, context: NameCollisionContext) => {
+  await uploadNewFilesOnly(root.childrenFiles, existingFolderUuid, context);
+
+  const {
+    unrepeatedItems: newFolders,
+    repeatedItems: collidingFolders,
+    existingItems: existingFolders,
+  } = await handleRepeatedUploadingFolders(root.childrenFolders, existingFolderUuid);
+
+  await uploadFolders(newFolders as IRoot[], existingFolderUuid, context);
+
+  await Promise.all(
+    (collidingFolders as IRoot[]).map(async (collidingFolder) => {
+      const existingFolder = existingFolders.find((folder) => folder.plainName === collidingFolder.name);
+      if (existingFolder) {
+        await mergeSkipFolderUpload(collidingFolder, existingFolder.uuid, context);
+      }
+    }),
+  );
+};
+
+/**
+ * Skipping uploaded files is a no-op (the existing files stay untouched), while
+ * skipping uploaded folders merges their new content into the existing folders.
+ */
+const skipAndUploadItems = async (
+  pairs: CollisionPair<IRoot | File>[],
+  destinationUuid: string,
+  context: NameCollisionContext,
+): Promise<void> => {
+  const folderPairs = pairs.filter((pair) => isFolderUpload(pair.item));
+  if (folderPairs.length === 0) return;
+
+  await Promise.all(folderPairs.map((pair) => mergeSkipFolderUpload(pair.item as IRoot, pair.existing.uuid, context)));
+  await context.dispatch(fetchSortedFolderContentThunk(destinationUuid));
+};
+
+const getFileLookupItem = (file: File): DriveItemData => {
+  const { filename, extension } = itemUtils.getFilenameAndExt(file.name);
+  return { name: filename, plainName: filename, type: extension, isFolder: false } as DriveItemData;
+};
+
+const getUniquelyNamedFiles = async (files: File[], destinationUuid: string): Promise<File[]> => {
+  const lookupItems = files.map(getFileLookupItem);
+  const namedItems = await getUniqueNames(lookupItems, destinationUuid);
+
+  return namedItems.map(({ item, uniqueName }) =>
+    renameFile(files[lookupItems.indexOf(item)], itemUtils.getItemDisplayName({ name: uniqueName, type: item.type })),
+  );
+};
+
+/**
+ * Uploads the items next to the existing ones under a name that does not collide with anything.
+ */
+const keepAndUploadItems = async (
+  items: (IRoot | File)[],
+  destinationUuid: string,
+  context: NameCollisionContext,
+): Promise<void> => {
+  if (items.length === 0) return;
+
+  const { folders, files } = splitFoldersAndFiles(items);
+  await uploadFolders(folders, destinationUuid, context);
+  await uploadFiles(await getUniquelyNamedFiles(files, destinationUuid), destinationUuid, context, true);
+  await context.dispatch(fetchSortedFolderContentThunk(destinationUuid));
+};
+
+/**
+ * Applies the chosen resolution to items that collide while being uploaded. Skipped files are
+ * left untouched, while skipped folders merge their new content into the existing folder.
+ */
+const resolveUploadCollision = async (
+  { operation, items, existingItems, destinationUuid }: ResolveUploadCollisionParams,
+  context: NameCollisionContext,
+) => {
+  if (operation === 'keep') {
+    await keepAndUploadItems(items, destinationUuid, context);
+    return;
+  }
+
+  const pairs = getCollisionPairs(items, existingItems);
+  if (operation === 'replace') {
+    await replaceAndUploadItems(pairs, destinationUuid, context);
+  } else {
+    await skipAndUploadItems(pairs, destinationUuid, context);
+  }
+};
+
+/**
+ * Applies the chosen collision resolution to the given items.
+ */
+export const resolveCollision = async (
+  { operationType, items, ...params }: ResolveCollisionParams,
+  context: NameCollisionContext,
+): Promise<void> => {
+  if (operationType === 'move') {
+    await resolveMoveCollision({ ...params, items: items as DriveItemData[] }, context);
+  } else {
+    await resolveUploadCollision({ ...params, items: items as (IRoot | File)[] }, context);
+  }
+};
diff --git a/src/app/drive/components/NameCollisionDialog/nameCollision.utils.test.ts b/src/app/drive/components/NameCollisionDialog/nameCollision.utils.test.ts
new file mode 100644
index 0000000000..1629db9f8f
--- /dev/null
+++ b/src/app/drive/components/NameCollisionDialog/nameCollision.utils.test.ts
@@ -0,0 +1,213 @@
+import { describe, expect, test } from 'vitest';
+import { getDriveItemData } from 'testUtils/fixtures/drive.fixtures';
+import { CollisionGroup } from 'app/store/slices/storage/storage.model';
+import { IRoot } from 'app/store/slices/storage/types';
+import {
+  CollisionItem,
+  findExistingItemFor,
+  findPendingGroupIndex,
+  getCollisionPairs,
+  getNameSeriesKey,
+  getRemainingGroups,
+  getUnpairedItems,
+  groupByNameSeries,
+  isFolderUpload,
+  isNameTakenBy,
+  splitReplacingPairs,
+} from './nameCollision.utils';
+
+const getRoot = (name = 'Photos'): IRoot => ({
+  name,
+  folderId: null,
+  childrenFiles: [],
+  childrenFolders: [],
+  fullPathEdited: `/${name}`,
+});
+
+const getGroup = (overrides: Partial<CollisionGroup> = {}): CollisionGroup => ({
+  destinationUuid: 'destination-uuid',
+  duplicatedItems: [],
+  existingItems: [],
+  unrepeatedItems: [],
+  ...overrides,
+});
+
+const existingFile = getDriveItemData({ uuid: 'file', plainName: 'report', type: 'pdf', isFolder: false });
+const existingFolder = getDriveItemData({ uuid: 'folder', plainName: 'report', type: null as never, isFolder: true });
+const existingNamedByName = getDriveItemData({
+  uuid: 'legacy',
+  name: 'README',
+  plainName: undefined,
+  type: null as never,
+});
+const existingItems = [existingFile, existingFolder, existingNamedByName];
+
+describe('isFolderUpload', () => {
+  test('when the item has an edited full path, then it is an uploaded folder', () => {
+    expect(isFolderUpload(getRoot())).toBe(true);
+    expect(isFolderUpload(new File([''], 'notes.txt'))).toBe(false);
+    expect(isFolderUpload(getDriveItemData({ isFolder: true }))).toBe(false);
+  });
+});
+
+describe('findExistingItemFor', () => {
+  test.each<[string, CollisionItem, ReturnType<typeof getDriveItemData> | undefined]>([
+    ['an uploaded folder with the same name', getRoot('report'), existingFolder],
+    ['an uploaded folder whose name only matches a file', getRoot('README'), undefined],
+    ['an uploaded file with the same name and extension', new File([''], 'report.pdf'), existingFile],
+    ['an uploaded file with the same name but another extension', new File([''], 'report.docx'), undefined],
+    [
+      'an uploaded file without extension against a legacy item named by name',
+      new File([''], 'README'),
+      existingNamedByName,
+    ],
+    ['a moved file with the same name and type', getDriveItemData({ plainName: 'report', type: 'pdf' }), existingFile],
+    [
+      'a moved file with the same name but another type',
+      getDriveItemData({ plainName: 'report', type: 'docx' }),
+      undefined,
+    ],
+    [
+      'a moved folder with the same name regardless of type',
+      getDriveItemData({ plainName: 'report', type: 'x', isFolder: true }),
+      existingFolder,
+    ],
+    [
+      'a moved item without plainName',
+      getDriveItemData({ name: 'README', plainName: undefined, type: null as never }),
+      existingNamedByName,
+    ],
+  ])('when given %s, then the matching item is returned', (_, item, expected) => {
+    expect(findExistingItemFor(item, existingItems)).toBe(expected);
+  });
+});
+
+describe('getCollisionPairs', () => {
+  test('when only some items collide, then only those are paired with their existing item', () => {
+    const matched = new File([''], 'report.pdf');
+
+    expect(getCollisionPairs([matched, new File([''], 'unknown.txt')], existingItems)).toEqual([
+      { item: matched, existing: existingFile },
+    ]);
+  });
+});
+
+describe('getUnpairedItems', () => {
+  test('when only some items collide, then the items without an existing item are returned', () => {
+    const unmatched = new File([''], 'unknown.txt');
+
+    expect(getUnpairedItems([new File([''], 'report.pdf'), unmatched], existingItems)).toEqual([unmatched]);
+  });
+});
+
+describe('findPendingGroupIndex', () => {
+  test('when several groups exist, then the first one with duplicated items is returned', () => {
+    const pending = getGroup({ duplicatedItems: [new File([''], 'a.txt')] });
+
+    expect(findPendingGroupIndex([getGroup(), pending, getGroup()])).toBe(1);
+    expect(findPendingGroupIndex([getGroup()])).toBe(-1);
+  });
+});
+
+describe('getRemainingGroups', () => {
+  const otherGroup = getGroup({ destinationUuid: 'other', duplicatedItems: [new File([''], 'c.txt')] });
+
+  test('when the handled group still has items, then it keeps the rest and drops the replaced existing item', () => {
+    const [first, second] = [new File([''], 'a.txt'), new File([''], 'b.txt')];
+    const groups = [
+      getGroup({ duplicatedItems: [first, second], existingItems: [existingFile, existingFolder] }),
+      otherGroup,
+    ];
+
+    expect(getRemainingGroups(groups, 0, existingFile)).toEqual([
+      { ...groups[0], duplicatedItems: [second], existingItems: [existingFolder] },
+      otherGroup,
+    ]);
+  });
+
+  test('when the handled item did not replace any existing item, then every existing item stays in the group', () => {
+    const [first, second] = [new File([''], 'a.txt'), new File([''], 'b.txt')];
+    const groups = [getGroup({ duplicatedItems: [first, second], existingItems: [existingFile, existingFolder] })];
+
+    expect(getRemainingGroups(groups, 0, undefined)).toEqual([
+      { ...groups[0], duplicatedItems: [second], existingItems: [existingFile, existingFolder] },
+    ]);
+  });
+
+  test('when the handled group had a single item, then it is dropped from the result', () => {
+    const groups = [
+      getGroup({ duplicatedItems: [new File([''], 'a.txt')], existingItems: [existingFile] }),
+      otherGroup,
+    ];
+
+    expect(getRemainingGroups(groups, 0, undefined)).toEqual([otherGroup]);
+  });
+});
+
+describe('splitReplacingPairs', () => {
+  test('when several items collide with the same existing item, then only the first one replaces it and the rest are left over', () => {
+    const first = getDriveItemData({ uuid: 'first', plainName: 'report', type: 'pdf' });
+    const second = getDriveItemData({ uuid: 'second', plainName: 'report', type: 'pdf' });
+    const folder = getDriveItemData({ uuid: 'moved-folder', plainName: 'report', isFolder: true });
+
+    expect(splitReplacingPairs(getCollisionPairs([first, folder, second], existingItems))).toEqual({
+      replacingPairs: [
+        { item: first, existing: existingFile },
+        { item: folder, existing: existingFolder },
+      ],
+      leftoverItems: [second],
+    });
+  });
+});
+
+describe('isNameTakenBy', () => {
+  const movedFile = getDriveItemData({ plainName: 'draft', type: 'pdf', isFolder: false });
+  const movedFolder = getDriveItemData({ plainName: 'draft', type: null as never, isFolder: true });
+
+  test.each<[string, string, ReturnType<typeof getDriveItemData>, boolean]>([
+    ['a file of the same extension holds the name', 'report', movedFile, true],
+    ['only a file of another extension holds the name', 'report', { ...movedFile, type: 'docx' }, false],
+    ['a folder holds the name wanted by a folder', 'report', movedFolder, true],
+    ['only a file holds the name wanted by a folder', 'README', movedFolder, false],
+    ['nothing holds the name', 'draft', movedFile, false],
+  ])('when %s, then it is reported accordingly', (_, name, item, expected) => {
+    expect(isNameTakenBy(name, item, existingItems)).toBe(expected);
+  });
+});
+
+describe('getNameSeriesKey', () => {
+  const file = getDriveItemData({ type: 'pdf', isFolder: false });
+  const folder = getDriveItemData({ type: null as never, isFolder: true });
+
+  test.each<[string, ReturnType<typeof getDriveItemData>, string, boolean]>([
+    ['the same name and extension', file, 'report', true],
+    ['the same name with an increment', file, 'report (1)', true],
+    ['the same name in another casing', { ...file, type: 'PDF' }, 'Report (12)', true],
+    ['another name', file, 'other', false],
+    ['the same name with another extension', { ...file, type: 'docx' }, 'report', false],
+    ['the same name as a folder', folder, 'report', false],
+    ['an increment that is not at the end of the name', file, 'report (1) final', false],
+  ])('when a file is compared with %s, then the series match is reported', (_, item, name, expected) => {
+    const isSameSeries = getNameSeriesKey(item, name) === getNameSeriesKey(file, 'report');
+
+    expect(isSameSeries).toBe(expected);
+  });
+
+  test('when two folders share a name and only differ in the increment and the type, then they belong to the same series', () => {
+    const typedFolder = { ...folder, type: 'pdf' };
+
+    expect(getNameSeriesKey(typedFolder, 'report (2)')).toBe(getNameSeriesKey(folder, 'report'));
+  });
+});
+
+describe('groupByNameSeries', () => {
+  test('when some items belong to the same name series, then they are grouped together in their given order', () => {
+    const first = getDriveItemData({ uuid: 'first', name: 'report', type: 'pdf', isFolder: false });
+    const other = getDriveItemData({ uuid: 'other', name: 'other', type: 'pdf', isFolder: false });
+    const second = getDriveItemData({ uuid: 'second', name: 'report (1)', type: 'pdf', isFolder: false });
+
+    const series = groupByNameSeries([first, other, second], (item) => item.name);
+
+    expect(series).toEqual([[first, second], [other]]);
+  });
+});
diff --git a/src/app/drive/components/NameCollisionDialog/nameCollision.utils.ts b/src/app/drive/components/NameCollisionDialog/nameCollision.utils.ts
new file mode 100644
index 0000000000..9fcd967aa4
--- /dev/null
+++ b/src/app/drive/components/NameCollisionDialog/nameCollision.utils.ts
@@ -0,0 +1,128 @@
+import { items as itemUtils } from '@internxt/lib';
+import { DriveItemData } from 'app/drive/types';
+import { CollisionGroup } from 'app/store/slices/storage/storage.model';
+import { IRoot } from 'app/store/slices/storage/types';
+
+export type CollisionItem = File | IRoot | DriveItemData;
+
+export type CollisionPair<T extends CollisionItem = CollisionItem> = { item: T; existing: DriveItemData };
+
+export const isFolderUpload = (item: CollisionItem): item is IRoot => !!(item as IRoot).fullPathEdited;
+
+const matchesName = (existing: DriveItemData, name: string) => (existing.plainName ?? existing.name) === name;
+
+const matchesType = (existing: DriveItemData, type?: string | null) => (existing.type ?? null) === (type ?? null);
+
+/**
+ * Finds the drive item that collides with the given item. Folders only match folders and files
+ * only match files; uploaded folders match by name, uploaded files by name and extension, and
+ * moved items by name and (for files) extension.
+ */
+export const findExistingItemFor = (item: CollisionItem, existingItems: DriveItemData[]): DriveItemData | undefined => {
+  if (isFolderUpload(item)) {
+    return existingItems.find((existing) => existing.isFolder && matchesName(existing, item.name));
+  }
+
+  if (item instanceof File) {
+    const { filename, extension } = itemUtils.getFilenameAndExt(item.name);
+    return existingItems.find(
+      (existing) => !existing.isFolder && matchesName(existing, filename) && matchesType(existing, extension),
+    );
+  }
+
+  return existingItems.find(
+    (existing) =>
+      !!existing.isFolder === !!item.isFolder &&
+      matchesName(existing, item.plainName ?? item.name) &&
+      (item.isFolder || matchesType(existing, item.type)),
+  );
+};
+
+/**
+ * Pairs each item with the drive item it collides with, dropping items that have no match.
+ */
+export const getCollisionPairs = <T extends CollisionItem>(
+  items: T[],
+  existingItems: DriveItemData[],
+): CollisionPair<T>[] =>
+  items.flatMap((item) => {
+    const existing = findExistingItemFor(item, existingItems);
+    return existing ? [{ item, existing }] : [];
+  });
+
+export const getUnpairedItems = <T extends CollisionItem>(items: T[], existingItems: DriveItemData[]): T[] =>
+  items.filter((item) => !findExistingItemFor(item, existingItems));
+
+export const hasDuplicatedItems = (group: CollisionGroup): boolean => group.duplicatedItems.length > 0;
+
+export const findPendingGroupIndex = (groups: CollisionGroup[]): number => groups.findIndex(hasDuplicatedItems);
+
+/**
+ * Returns the groups still waiting for a decision once the first duplicated item of the group at
+ * `groupIndex` has been handled, without the existing item it replaced.
+ */
+export const getRemainingGroups = (
+  groups: CollisionGroup[],
+  groupIndex: number,
+  replacedExistingItem?: DriveItemData,
+): CollisionGroup[] =>
+  groups
+    .map((group, index) =>
+      index === groupIndex
+        ? {
+            ...group,
+            duplicatedItems: group.duplicatedItems.slice(1),
+            existingItems: group.existingItems.filter((existing) => existing !== replacedExistingItem),
+          }
+        : group,
+    )
+    .filter(hasDuplicatedItems);
+
+export interface ReplacingPairsSplit<T extends CollisionItem = CollisionItem> {
+  replacingPairs: CollisionPair<T>[];
+  leftoverItems: T[];
+}
+
+export const splitReplacingPairs = <T extends CollisionItem>(pairs: CollisionPair<T>[]): ReplacingPairsSplit<T> => {
+  const replacedUuids = new Set<string>();
+
+  return pairs.reduce<ReplacingPairsSplit<T>>(
+    (split, pair) => {
+      if (replacedUuids.has(pair.existing.uuid)) {
+        split.leftoverItems.push(pair.item);
+      } else {
+        replacedUuids.add(pair.existing.uuid);
+        split.replacingPairs.push(pair);
+      }
+      return split;
+    },
+    { replacingPairs: [], leftoverItems: [] },
+  );
+};
+
+export const isNameTakenBy = (name: string, item: DriveItemData, takenItems: DriveItemData[]): boolean =>
+  !!findExistingItemFor({ ...item, name, plainName: name }, takenItems);
+
+const INCREMENT_SUFFIX_REGEX = / \(\d+\)$/;
+
+export const getNameSeriesKey = (item: DriveItemData, name: string): string => {
+  const baseName = name.replace(INCREMENT_SUFFIX_REGEX, '').toLowerCase();
+  const extension = (item.type ?? '').toLowerCase();
+
+  return JSON.stringify(item.isFolder ? ['folder', baseName] : ['file', baseName, extension]);
+};
+
+export const groupByNameSeries = (
+  items: DriveItemData[],
+  getName: (item: DriveItemData) => string,
+): DriveItemData[][] => {
+  const itemsBySeriesKey = new Map<string, DriveItemData[]>();
+
+  for (const item of items) {
+    const seriesKey = getNameSeriesKey(item, getName(item));
+    const seriesItems = itemsBySeriesKey.get(seriesKey) ?? [];
+    itemsBySeriesKey.set(seriesKey, [...seriesItems, item]);
+  }
+
+  return [...itemsBySeriesKey.values()];
+};
diff --git a/src/app/i18n/locales/de.json b/src/app/i18n/locales/de.json
index 3655df7e5d..e36b8000a0 100644
--- a/src/app/i18n/locales/de.json
+++ b/src/app/i18n/locales/de.json
@@ -854,14 +854,14 @@
       "title": "Umbenennen",
       "label": "Name"
     },
-    "renameModal": {
+    "alreadyExistsModal": {
       "title": "Objekt existiert bereits",
-      "titleMultipleItems": "Es sind bereits mehrere Elemente vorhanden",
-      "description": "{{itemName}} existiert bereits an diesem Ort. Möchtest du es ersetzen oder möchtest du beide behalten?",
-      "multipleDescription": "An diesem Speicherort ist bereits mehr als ein Element vorhanden. Möchtest du sie ersetzen oder alle behalten?",
+      "selectOption": "Wähle eine Option",
+      "description": "{{itemName}} existiert bereits an diesem Ort. Was möchtest du tun?",
       "replaceItem": "Aktuelles Element ersetzen",
       "keepBoth": "Behalte beide",
-      "selectOption": "Wähle eine Option",
+      "skipItem": "Dieses Element überspringen",
+      "applyToAll": "Diese Aktion auf alle Duplikate anwenden",
       "upload": "Upload",
       "move": "Verschieben"
     },
diff --git a/src/app/i18n/locales/en.json b/src/app/i18n/locales/en.json
index fdbbf55ba2..ae881cf9e0 100644
--- a/src/app/i18n/locales/en.json
+++ b/src/app/i18n/locales/en.json
@@ -875,14 +875,14 @@
       "title": "Rename",
       "label": "Name"
     },
-    "renameModal": {
+    "alreadyExistsModal": {
       "title": "Item already exists",
-      "titleMultipleItems": "Multiple items already exist",
-      "description": "{{itemName}} already exists in this location. Do you want to replace it or you want to keep both?",
-      "multipleDescription": "More than one element already exists in this location. Do you want to replace them or you want to keep all",
+      "selectOption": "Select an option",
+      "description": "{{itemName}} already exists in this location. What would you like to do?",
       "replaceItem": "Replace current item",
       "keepBoth": "Keep both",
-      "selectOption": "Select an option",
+      "skipItem": "Skip this item",
+      "applyToAll": "Apply this action to all duplicates",
       "upload": "Upload",
       "move": "Move"
     },
diff --git a/src/app/i18n/locales/es.json b/src/app/i18n/locales/es.json
index 60b03797b5..b5655c5cee 100644
--- a/src/app/i18n/locales/es.json
+++ b/src/app/i18n/locales/es.json
@@ -854,14 +854,14 @@
       "title": "Renombrar",
       "label": "Nombre"
     },
-    "renameModal": {
+    "alreadyExistsModal": {
       "title": "El item ya existe",
-      "titleMultipleItems": "Multiples archivos existen",
-      "description": "{{itemName}} ya existe en esta carpeta. ¿Deseas reemplazarlo o mantener los dos?",
-      "multipleDescription": "Más de un elemento existe en esta localización. Deseas reemplazarlos o mantenerlos?",
+      "selectOption": "Selecciona una opción",
+      "description": "{{itemName}} ya existe en esta ubicación. ¿Qué deseas hacer?",
       "replaceItem": "Reemplazar el ítem",
       "keepBoth": "Mantener ambos",
-      "selectOption": "Selecciona una opción",
+      "skipItem": "Omitir este ítem",
+      "applyToAll": "Aplicar esta acción a todos los duplicados",
       "upload": "Subir",
       "move": "Mover"
     },
diff --git a/src/app/i18n/locales/fr.json b/src/app/i18n/locales/fr.json
index 7ace65a0ea..ab60578810 100644
--- a/src/app/i18n/locales/fr.json
+++ b/src/app/i18n/locales/fr.json
@@ -854,14 +854,14 @@
       "title": "Renommer",
       "label": "Nom"
     },
-    "renameModal": {
+    "alreadyExistsModal": {
       "title": "L'élément existe déjà",
-      "titleMultipleItems": "Plusieurs éléments existent déjà",
-      "description": "{{itemName}} existe déjà à cet endroit. Voulez-vous le remplacer ou conserver les deux ?",
-      "multipleDescription": "Plus d'un élément existe déjà dans ce lieu. Voulez-vous les remplacer ou les conserver tous ?",
+      "selectOption": "Sélectionnez une option",
+      "description": "{{itemName}} existe déjà à cet endroit. Que voulez-vous faire ?",
       "replaceItem": "Remplacer l'élément actuel",
       "keepBoth": "Garder les deux",
-      "selectOption": "Sélectionnez une option",
+      "skipItem": "Ignorer cet élément",
+      "applyToAll": "Appliquer cette action à tous les doublons",
       "upload": "Télécharger",
       "move": "Déplacer"
     },
diff --git a/src/app/i18n/locales/it.json b/src/app/i18n/locales/it.json
index 01c462904f..2eb0f1ce4b 100644
--- a/src/app/i18n/locales/it.json
+++ b/src/app/i18n/locales/it.json
@@ -875,14 +875,14 @@
       "title": "Rinominare",
       "label": "Nome"
     },
-    "renameModal": {
+    "alreadyExistsModal": {
       "title": "L'elemento esiste già",
-      "titleMultipleItems": "Esistono già più elementi",
-      "description": "Il {{itemName}} esiste già in questa posizione. Vuoi sostituirlo o vuoi mantenerli entrambi?",
-      "multipleDescription": "Più di un elemento esiste già in questa posizione. Si desidera sostituirli o si desidera mantenerli tutti",
+      "selectOption": "Seleziona un'opzione",
+      "description": "{{itemName}} esiste già in questa posizione. Cosa vuoi fare?",
       "replaceItem": "Sostituisci l'elemento attuale",
       "keepBoth": "Mantieni entrambi",
-      "selectOption": "Seleziona un'opzione",
+      "skipItem": "Salta questo elemento",
+      "applyToAll": "Applica questa azione a tutti i duplicati",
       "upload": "Carica",
       "move": "Sposta"
     },
diff --git a/src/app/i18n/locales/ru.json b/src/app/i18n/locales/ru.json
index ffc052880d..d9d340a1eb 100644
--- a/src/app/i18n/locales/ru.json
+++ b/src/app/i18n/locales/ru.json
@@ -854,14 +854,14 @@
       "title": "Переименовать",
       "label": "Имя."
     },
-    "renameModal": {
+    "alreadyExistsModal": {
       "title": "Файл уже существует",
-      "titleMultipleItems": "Несколько файлов уже существуют",
-      "description": "{{itemName}} уже существует. Заменить его или оставить оба?",
-      "multipleDescription": "Несколько файлов уже существуют. Заменить их или оставить все?",
+      "selectOption": "Выберите опцию",
+      "description": "{{itemName}} уже существует в этом месте. Что вы хотите сделать?",
       "replaceItem": "Заменить текущий файл",
       "keepBoth": "Сохранить оба",
-      "selectOption": "Выберите опцию",
+      "skipItem": "Пропустить этот элемент",
+      "applyToAll": "Применить это действие ко всем дубликатам",
       "upload": "Загрузить",
       "move": "Переместить"
     },
diff --git a/src/app/i18n/locales/tw.json b/src/app/i18n/locales/tw.json
index d05757332d..05020e629e 100644
--- a/src/app/i18n/locales/tw.json
+++ b/src/app/i18n/locales/tw.json
@@ -875,14 +875,14 @@
       "title": "重命名",
       "label": "名稱"
     },
-    "renameModal": {
+    "alreadyExistsModal": {
       "title": "項目已存在",
-      "titleMultipleItems": "多個項目已存在",
-      "description": "{{itemName}} 已存在於此位置。您要替換它還是保留兩者？",
-      "multipleDescription": "此位置已存在多個元素。您要替換它們還是保留全部？",
+      "selectOption": "選擇一個選項",
+      "description": "{{itemName}} 已存在於此位置。您要如何處理？",
       "replaceItem": "替換當前項目",
       "keepBoth": "保留兩者",
-      "selectOption": "選擇一個選項",
+      "skipItem": "跳過此項目",
+      "applyToAll": "將此操作套用至所有重複項目",
       "upload": "上傳",
       "move": "移動"
     },
diff --git a/src/app/i18n/locales/zh.json b/src/app/i18n/locales/zh.json
index ce83a78e8d..4a38994c5b 100644
--- a/src/app/i18n/locales/zh.json
+++ b/src/app/i18n/locales/zh.json
@@ -875,14 +875,14 @@
       "title": "重命名",
       "label": "名称"
     },
-    "renameModal": {
+    "alreadyExistsModal": {
       "title": "项目已经存在",
-      "titleMultipleItems": "多个项目已存在",
-      "description": "{{itemName}} 已存在于此位置。 你想替换它还是保留两者？",
-      "multipleDescription": "此位置已存在多个元素。 你想替换它们还是想保留所有",
+      "selectOption": "选择一个选项",
+      "description": "{{itemName}} 已存在于此位置。您要如何处理？",
       "replaceItem": "替换当前项目",
       "keepBoth": "保留两者",
-      "selectOption": "选择一个选项",
+      "skipItem": "跳过此项目",
+      "applyToAll": "将此操作应用于所有重复项",
       "upload": "上传",
       "move": "移动"
     },
diff --git a/src/app/store/slices/storage/storage.thunks/renameItemsThunk.test.ts b/src/app/store/slices/storage/storage.thunks/renameItemsThunk.test.ts
index 8e491991cb..115d5a73ae 100644
--- a/src/app/store/slices/storage/storage.thunks/renameItemsThunk.test.ts
+++ b/src/app/store/slices/storage/storage.thunks/renameItemsThunk.test.ts
@@ -89,9 +89,9 @@ describe('Rename items - Thunk', () => {
 
     test('When items collide in the destination, then they appear in duplicated items and existing items', async () => {
       const movingFile = getDriveItemData({ isFolder: false, uuid: 'file-moving' });
-      const existingFile = getDriveItemData({ isFolder: false, uuid: 'file-existing' });
+      const existingFile = getDriveItemData({ uuid: 'file-existing' });
       const movingFolder = getDriveItemData({ isFolder: true, uuid: 'folder-moving' });
-      const existingFolder = getDriveItemData({ isFolder: true, uuid: 'folder-existing' });
+      const existingFolder = getDriveItemData({ uuid: 'folder-existing' });
       mockCheckDuplicatedFiles.mockResolvedValue({
         filesWithDuplicates: [movingFile],
         duplicatedFilesResponse: [existingFile],
@@ -107,8 +107,10 @@ describe('Rename items - Thunk', () => {
 
       expect(result[0].duplicatedItems).toContain(movingFile);
       expect(result[0].duplicatedItems).toContain(movingFolder);
-      expect(result[0].existingItems).toContain(existingFile);
-      expect(result[0].existingItems).toContain(existingFolder);
+      expect(result[0].existingItems).toEqual([
+        { ...existingFile, isFolder: false },
+        { ...existingFolder, isFolder: true },
+      ]);
       expect(result[0].unrepeatedItems).toHaveLength(0);
     });
 
@@ -176,7 +178,7 @@ describe('Rename items - Thunk', () => {
       const result = await handleRepeatedUploadingFiles([file], 'dest-uuid');
 
       expect(result.repeatedItems).toContain(file);
-      expect(result.existingItems).toContain(file);
+      expect(result.existingItems).toEqual([{ ...file, isFolder: false }]);
       expect(result.unrepeatedItems).toHaveLength(0);
     });
 
@@ -214,16 +216,17 @@ describe('Rename items - Thunk', () => {
   describe('Handling repeated folders', () => {
     test('When a folder has a duplicate in the destination, it is returned as a repeated item', async () => {
       const folder = getDriveItemData({ isFolder: true });
+      const existingFolder = getDriveItemData({ uuid: 'existing-folder' });
       mockCheckFolderDuplicated.mockResolvedValue({
         foldersWithDuplicates: [folder],
-        duplicatedFoldersResponse: [folder],
+        duplicatedFoldersResponse: [existingFolder],
         foldersWithoutDuplicates: [],
       });
 
       const result = await handleRepeatedUploadingFolders([folder], 'dest-uuid');
 
       expect(result.repeatedItems).toContain(folder);
-      expect(result.existingItems).toContain(folder);
+      expect(result.existingItems).toEqual([{ ...existingFolder, isFolder: true }]);
       expect(result.unrepeatedItems).toHaveLength(0);
     });
 
diff --git a/src/app/store/slices/storage/storage.thunks/renameItemsThunk.ts b/src/app/store/slices/storage/storage.thunks/renameItemsThunk.ts
index dc4a905d7a..e7092fb811 100644
--- a/src/app/store/slices/storage/storage.thunks/renameItemsThunk.ts
+++ b/src/app/store/slices/storage/storage.thunks/renameItemsThunk.ts
@@ -17,6 +17,9 @@ import { getUniqueFolderName } from '../folderUtils/getUniqueFolderName';
 import { CollisionGroup, StorageState } from '../storage.model';
 import { IRoot } from '../types';
 
+const addIsFolderField = (items: (DriveFileData | DriveFolderData)[], isFolder: boolean): DriveItemData[] =>
+  items.map((item) => ({ ...item, isFolder })) as DriveItemData[];
+
 export const getCollisionGroups = async (
   groups: { destinationUuid: string; items: DriveItemData[] }[],
 ): Promise<CollisionGroup[]> => {
@@ -39,8 +42,8 @@ export const getCollisionGroups = async (
         ...(foldersResult.foldersWithDuplicates as DriveItemData[]),
       ];
       const existingItems = [
-        ...(filesResult.duplicatedFilesResponse as DriveItemData[]),
-        ...(foldersResult.duplicatedFoldersResponse as DriveItemData[]),
+        ...addIsFolderField(filesResult.duplicatedFilesResponse, false),
+        ...addIsFolderField(foldersResult.duplicatedFoldersResponse, true),
       ];
       const unrepeatedItems = [
         ...(filesResult.filesWithoutDuplicates as DriveItemData[]),
@@ -62,7 +65,7 @@ export const handleRepeatedUploadingFiles = async (
   destinationFolderUuid: string,
 ): Promise<{
   repeatedItems: (DriveFileData | File)[];
-  existingItems: DriveFileData[];
+  existingItems: DriveItemData[];
   unrepeatedItems: (DriveFileData | File)[];
 }> => {
   const batchs = getFilesByBatchs(files);
@@ -73,13 +76,13 @@ export const handleRepeatedUploadingFiles = async (
   return results.reduce(
     (acc, cur) => {
       acc.repeatedItems.push(...cur.filesWithDuplicates);
-      acc.existingItems.push(...cur.duplicatedFilesResponse);
+      acc.existingItems.push(...addIsFolderField(cur.duplicatedFilesResponse, false));
       acc.unrepeatedItems.push(...cur.filesWithoutDuplicates);
       return acc;
     },
     {
       repeatedItems: [] as (DriveFileData | File)[],
-      existingItems: [] as DriveFileData[],
+      existingItems: [] as DriveItemData[],
       unrepeatedItems: [] as (DriveFileData | File)[],
     },
   );
@@ -90,7 +93,7 @@ export const handleRepeatedUploadingFolders = async (
   destinationFolderUuid: string,
 ): Promise<{
   repeatedItems: (DriveFolderData | IRoot)[];
-  existingItems: DriveFolderData[];
+  existingItems: DriveItemData[];
   unrepeatedItems: (DriveFolderData | IRoot)[];
 }> => {
   const batchs = getFilesByBatchs(folders as (IRoot | DriveFolderData)[]);
@@ -101,13 +104,13 @@ export const handleRepeatedUploadingFolders = async (
   return results.reduce(
     (acc, cur) => {
       acc.repeatedItems.push(...cur.foldersWithDuplicates);
-      acc.existingItems.push(...cur.duplicatedFoldersResponse);
+      acc.existingItems.push(...addIsFolderField(cur.duplicatedFoldersResponse, true));
       acc.unrepeatedItems.push(...cur.foldersWithoutDuplicates);
       return acc;
     },
     {
       repeatedItems: [] as (DriveFolderData | IRoot)[],
-      existingItems: [] as DriveFolderData[],
+      existingItems: [] as DriveItemData[],
       unrepeatedItems: [] as (DriveFolderData | IRoot)[],
     },
   );
diff --git a/src/app/tasks/components/TaskLogger/TaskLogger.tsx b/src/app/tasks/components/TaskLogger/TaskLogger.tsx
index 33c3440ce2..5615b055b8 100644
--- a/src/app/tasks/components/TaskLogger/TaskLogger.tsx
+++ b/src/app/tasks/components/TaskLogger/TaskLogger.tsx
@@ -100,6 +100,7 @@ const TaskLogger = (): JSX.Element => {
 
   return (
     <div
+      data-test="task-logger"
       className={`absolute bottom-5 right-5 z-40 flex w-96 flex-col shadow-subtle-hard transition-height duration-350 ${
         isMinimized ? 'h-11' : 'h-72'
       } overflow-hidden rounded-xl border border-gray-10 bg-surface dark:bg-gray-1 ${!isOpen ? 'hidden' : ''}`}
diff --git a/src/views/Drive/components/DriveExplorer/components/DriveExplorerList/DriveExplorerListItem.tsx b/src/views/Drive/components/DriveExplorer/components/DriveExplorerList/DriveExplorerListItem.tsx
index deacb7c3a0..e8be138e68 100644
--- a/src/views/Drive/components/DriveExplorer/components/DriveExplorerList/DriveExplorerListItem.tsx
+++ b/src/views/Drive/components/DriveExplorer/components/DriveExplorerList/DriveExplorerListItem.tsx
@@ -196,7 +196,13 @@ const DriveExplorerListItem = ({ item, isTrash }: DriveExplorerItemProps): JSX.E
 
       {
         /* DROPPABLE ZONE */
-        isInteractive && connectDropTarget(<div className="absolute top-0 h-full w-1/2 group-hover:invisible"></div>)
+        isInteractive &&
+          connectDropTarget(
+            <div
+              className="absolute top-0 h-full w-1/2 group-hover:invisible"
+              data-test={`${basicFileDataTest}-drop-zone`}
+            ></div>,
+          )
       }
 
       {/* AUTO-DELETE (only for trash) */}
diff --git a/test/e2e/tests/helper/authRouteMocks.ts b/test/e2e/tests/helper/authRouteMocks.ts
index e5744cc803..d0fe3f64c4 100644
--- a/test/e2e/tests/helper/authRouteMocks.ts
+++ b/test/e2e/tests/helper/authRouteMocks.ts
@@ -1,13 +1,15 @@
-import { expect, Page, Route } from '@playwright/test';
+import { expect, Page, Request, Route } from '@playwright/test';
 import { LoginPage } from '../pages/loginPage';
 import { getLoggedUser, getUserCredentials } from './getUser';
 import { staticData } from './staticData';
 
 export const BASE_API_URL = process.env.REACT_APP_DRIVE_NEW_API_URL;
+export const INVALID_EMAIL = 'invalid@internxt.com';
 
 const LOGIN_URL_PATTERN = /\/login$/;
 const LOGIN_SALT_KEY =
   '53616c7465645f5f2aa5386bc0b15f6f69a733acdd46a6551dc004f6c1cb6352390535de3ec17e9b96da7de984e5d27e79ad04a88a2cc8c6315f03dc0b0d174c';
+const HTTP_BAD_REQUEST = 400;
 
 export const loggedUser = getLoggedUser();
 
@@ -16,8 +18,13 @@ const mockLoginCall = (route: Route) =>
     json: { hasKeys: true, sKey: LOGIN_SALT_KEY, tfa: false, hasKyberKeys: true, hasEccKeys: true },
   });
 
-const mockAccessCall = (route: Route) =>
-  route.fulfill({
+const mockAccessCall = (route: Route, request: Request) => {
+  const { email } = request.postDataJSON();
+  if (email === INVALID_EMAIL) {
+    return route.fulfill({ status: HTTP_BAD_REQUEST, json: { message: staticData.wrongLoginWarning } });
+  }
+
+  return route.fulfill({
     json: {
       user: loggedUser.user,
       token: loggedUser.token,
@@ -25,6 +32,7 @@ const mockAccessCall = (route: Route) =>
       userTeam: loggedUser.userTeam,
     },
   });
+};
 
 const mockRefreshUserCall = (route: Route) =>
   route.fulfill({ json: { user: loggedUser.user, newToken: loggedUser.newToken } });
diff --git a/test/e2e/tests/helper/driveRouteMocks.ts b/test/e2e/tests/helper/driveRouteMocks.ts
index 69a739a024..1dd1fc75ae 100644
--- a/test/e2e/tests/helper/driveRouteMocks.ts
+++ b/test/e2e/tests/helper/driveRouteMocks.ts
@@ -10,38 +10,56 @@ const SHARDS_URL = 'https://e2e-shards.internxt.test';
 const FOLDER_CONTENT_UUID_PATTERN = /\/folders\/content\/([^/?]+)/;
 const FILE_META_UUID_PATTERN = /\/files\/([^/]+)\/meta/;
 const BRIDGE_FILE_INFO_ID_PATTERN = /\/files\/([^/]+)\/info/;
+const FOLDER_NAVIGATION_UUID_PATTERN = /\/folders\/([^/?]+)\/(meta|ancestors)/;
 const FILES_LISTING_PATH = '/files/';
 const START_UPLOAD_PATH = '/files/start';
 const FINISH_UPLOAD_PATH = '/files/finish';
+const FILES_EXISTENCE_PATH = '/files/existence';
+const FOLDERS_EXISTENCE_PATH = '/folders/existence';
 
-const HTTP_METHOD = { get: 'GET', post: 'POST', put: 'PUT' };
+const HTTP_METHOD = { get: 'GET', post: 'POST', put: 'PUT', patch: 'PATCH' };
 const HTTP_NOT_FOUND = 404;
+const HTTP_INTERNAL_SERVER_ERROR = 500;
 const SHARD_CONTENT_TYPE = 'application/octet-stream';
 
 const BRIDGE_FILE_VERSION = 2;
 const BRIDGE_FILE_ID_BYTES = 12;
 const FIRST_UPLOADED_FILE_ID = 5000;
 const FIRST_THUMBNAIL_ID = 9000;
+const FIRST_CREATED_FOLDER_ID = 1000;
+const EXISTING_FILE_SIZE = 1024;
 const ITEM_TIMESTAMP = '2026-08-01T10:00:00.000Z';
 const ITEM_STATUS = 'EXISTS';
+const TRASHED_ITEM_STATUS = 'TRASHED';
+const TRASH_PAGE_DEFAULT_LIMIT = 50;
 
+const MEGABYTE = 1024 ** 2;
 const GIGABYTE = 1024 ** 3;
 const MAX_UPLOAD_FILE_SIZE = 20 * GIGABYTE;
 const MAX_SPACE_BYTES = 10 * GIGABYTE;
 const USED_SPACE_BYTES = 3072;
+const MAX_FILE_VERSIONS = 5;
+const VERSIONING_MAX_FILE_SIZE = 20 * MEGABYTE;
 
 const NO_DUPLICATES = { existentFiles: [], existentFolders: [] };
-const BOOTSTRAP_RESPONSES: Record<string, unknown> = {
+const buildBootstrapResponses = (isVersioningEnabled: boolean): Record<string, unknown> => ({
   'workspaces/': { availableWorkspaces: [], pendingWorkspaces: [] },
   'sharings/invites**': { invites: [] },
   'sharings/roles': [],
-  'files/limits': { versioning: { enabled: false, maxVersions: 0 }, maxUploadFileSize: MAX_UPLOAD_FILE_SIZE },
+  'files/limits': {
+    versioning: {
+      enabled: isVersioningEnabled,
+      maxVersions: MAX_FILE_VERSIONS,
+      maxFileSize: VERSIONING_MAX_FILE_SIZE,
+    },
+    maxUploadFileSize: MAX_UPLOAD_FILE_SIZE,
+  },
   'users/limit': { maxSpaceBytes: MAX_SPACE_BYTES },
   'users/usage': { drive: USED_SPACE_BYTES, backups: 0, total: USED_SPACE_BYTES },
   'users/me/upload-status': { hasUploadedFiles: true },
   'users/avatar/refresh': { avatar: null },
   'referral/enabled': { enabled: false },
-};
+});
 
 type RouteHandler = (route: Route, request: Request) => Promise<void>;
 type FileEntryRequest = {
@@ -68,13 +86,33 @@ type FinishUploadRequest = {
   hmac?: { type: string; value: string };
 };
 
+type ExistenceCheckRequest = { files: { plainName: string; type: string }[] };
+type FolderExistenceCheckRequest = { plainNames: string[] };
+export type TrashRequest = { items: { uuid: string; type: string }[] };
+export type MoveRequest = { uuid: string; destinationFolder: string; name?: string };
+export type CreateFolderRequest = { plainName: string; parentFolderUuid: string };
+
+export const ROOT_FOLDER_UUID: string = loggedUser.user.rootFolderId;
+
+/**
+ * Uploads only reach the bridge, and so `fileEntries`, in Chromium: Playwright cannot route
+ * the bridge CORS preflight in Firefox.
+ */
 type RecordedRequests = {
   fileEntries: FileEntryRequest[];
   thumbnailEntries: ThumbnailEntryRequest[];
   downloadedFileIds: string[];
+  trash: TrashRequest[];
+  moves: MoveRequest[];
+  createdFolders: CreateFolderRequest[];
+  replacedFileUuids: string[];
 };
 export type MockedDriveOptions = {
+  files?: ExistingFile[];
+  folders?: ExistingFolder[];
+  trashedFiles?: TrashedFile[];
   declaredSizes?: Record<string, number>;
+  isVersioningEnabled?: boolean;
 };
 
 const buildThumbnail = (id: number, fileId: number, entry: ThumbnailEntryRequest) => ({
@@ -90,12 +128,16 @@ const buildThumbnail = (id: number, fileId: number, entry: ThumbnailEntryRequest
 });
 type StoredThumbnail = ReturnType<typeof buildThumbnail>;
 
-const buildFile = (id: number, { fileId, type, size, plainName, bucket, folderUuid }: FileEntryRequest) => {
+const buildFile = (
+  id: number,
+  { fileId, type, size, plainName, bucket, folderUuid }: FileEntryRequest,
+  uuid: string = randomUUID(),
+) => {
   const thumbnails: StoredThumbnail[] = [];
 
   return {
     id,
-    uuid: randomUUID(),
+    uuid,
     fileId,
     name: plainName,
     plainName,
@@ -112,23 +154,151 @@ const buildFile = (id: number, { fileId, type, size, plainName, bucket, folderUu
 };
 type StoredFile = ReturnType<typeof buildFile>;
 
+export const buildExistingFile = (id: number, plainName: string, type: string, folderUuid = ROOT_FOLDER_UUID) =>
+  buildFile(
+    id,
+    {
+      fileId: `existing-bridge-file-${id}`,
+      type,
+      size: EXISTING_FILE_SIZE,
+      plainName,
+      bucket: loggedUser.user.bucket,
+      folderUuid,
+    },
+    `existing-file-uuid-${id}`,
+  );
+export type ExistingFile = StoredFile;
+
+const toTrashedFile = (file: ExistingFile, originalFolderUuid: string) => ({
+  ...file,
+  status: TRASHED_ITEM_STATUS,
+  parent: { uuid: originalFolderUuid, status: ITEM_STATUS },
+});
+
+export const buildTrashedFile = (id: number, plainName: string, type: string, originalFolderUuid = ROOT_FOLDER_UUID) =>
+  toTrashedFile(buildExistingFile(id, plainName, type, originalFolderUuid), originalFolderUuid);
+export type TrashedFile = ReturnType<typeof buildTrashedFile>;
+
+export const buildExistingFolder = (id: number, plainName: string, parentUuid = ROOT_FOLDER_UUID) => ({
+  id,
+  uuid: `existing-folder-uuid-${id}`,
+  name: plainName,
+  plainName,
+  plain_name: plainName,
+  parentUuid,
+  parentId: null,
+  bucket: loggedUser.user.bucket,
+  createdAt: ITEM_TIMESTAMP,
+  updatedAt: ITEM_TIMESTAMP,
+  deleted: false,
+  removed: false,
+});
+export type ExistingFolder = ReturnType<typeof buildExistingFolder>;
+
+const ROOT_FOLDER: ExistingFolder = { ...buildExistingFolder(0, 'Drive', ''), uuid: ROOT_FOLDER_UUID };
+
+/**
+ * Trashing, creating and moving update it, so follow-up listings and existence checks
+ * see the new state.
+ */
 class InMemoryDrive {
-  private readonly files: StoredFile[] = [];
+  private files: StoredFile[];
+  private folders: ExistingFolder[];
+  private trashedFiles: TrashedFile[];
+  private readonly declaredSizes: Record<string, number>;
+  private uploadedFilesCount = 0;
   private thumbnailsCount = 0;
+  private createdFoldersCount = 0;
 
-  constructor(private readonly declaredSizes: Record<string, number> = {}) {}
+  constructor({ files = [], folders = [], trashedFiles = [], declaredSizes = {} }: MockedDriveOptions) {
+    this.files = [...files];
+    this.folders = [...folders];
+    this.trashedFiles = [...trashedFiles];
+    this.declaredSizes = declaredSizes;
+  }
+
+  trashedFilesPage(offset: number, limit: number) {
+    return this.trashedFiles.slice(offset, offset + limit).map((file) => ({
+      ...file,
+      parent: { ...file.parent, plainName: this.findFolder(file.parent.uuid)?.plainName },
+    }));
+  }
+
+  moveFile({ uuid, destinationFolder, name }: MoveRequest) {
+    const file = [...this.files, ...this.trashedFiles].find((candidate) => candidate.uuid === uuid);
+    if (!file) return;
+
+    const movedFile: ExistingFile = {
+      ...buildExistingFile(file.id, name ?? file.plainName, file.type, destinationFolder),
+      uuid: file.uuid,
+      fileId: file.fileId,
+    };
+
+    this.files = this.files.filter((candidate) => candidate.uuid !== uuid);
+    this.trashedFiles = this.trashedFiles.filter((candidate) => candidate.uuid !== uuid);
+    this.files.push(movedFile);
+  }
 
   filesIn(folderUuid: string) {
     return this.files.filter((file) => file.folderUuid === folderUuid);
   }
 
+  existingFilesIn(folderUuid: string, candidates: ExistenceCheckRequest['files']) {
+    return this.filesIn(folderUuid).filter((existing) =>
+      candidates.some(({ plainName, type }) => plainName === existing.plainName && type === existing.type),
+    );
+  }
+
+  foldersIn(folderUuid: string) {
+    return this.folders.filter((folder) => folder.parentUuid === folderUuid);
+  }
+
+  existingFoldersIn(folderUuid: string, plainNames: string[]) {
+    return this.foldersIn(folderUuid).filter((existing) => plainNames.includes(existing.plainName));
+  }
+
+  findFolder(folderUuid: string) {
+    return this.folders.find((folder) => folder.uuid === folderUuid);
+  }
+
+  ancestorsOf(folderUuid: string) {
+    const ancestors: ExistingFolder[] = [];
+    let folder = this.findFolder(folderUuid);
+
+    while (folder) {
+      ancestors.push(folder);
+      folder = this.findFolder(folder.parentUuid);
+    }
+
+    return [...ancestors, ROOT_FOLDER];
+  }
+
+  createFolder({ plainName, parentFolderUuid }: CreateFolderRequest) {
+    const folder = buildExistingFolder(FIRST_CREATED_FOLDER_ID + this.createdFoldersCount, plainName, parentFolderUuid);
+    this.createdFoldersCount += 1;
+    this.folders.push(folder);
+    return folder;
+  }
+
+  trash(uuids: string[]) {
+    const trashed = new Set(uuids);
+    const newlyTrashedFiles = this.files
+      .filter((file) => trashed.has(file.uuid))
+      .map((file) => toTrashedFile(file, file.folderUuid));
+
+    this.trashedFiles.push(...newlyTrashedFiles);
+    this.files = this.files.filter((file) => !trashed.has(file.uuid));
+    this.folders = this.folders.filter((folder) => !trashed.has(folder.uuid));
+  }
+
   findFile(uuid: string) {
     return this.files.find((file) => file.uuid === uuid);
   }
 
   addFile(entry: FileEntryRequest) {
     const size = this.declaredSizes[entry.plainName] ?? entry.size;
-    const file = buildFile(FIRST_UPLOADED_FILE_ID + this.files.length, { ...entry, size });
+    const file = buildFile(FIRST_UPLOADED_FILE_ID + this.uploadedFilesCount, { ...entry, size });
+    this.uploadedFilesCount += 1;
     this.files.push(file);
     return file;
   }
@@ -200,26 +370,54 @@ const fulfillJsonIfFound = (route: Route, body: object | undefined) =>
 const mockRouteForMethod = (page: Page, url: string, method: string, handler: RouteHandler) =>
   page.route(url, (route, request) => (request.method() === method ? handler(route, request) : route.fallback()));
 
-const mockAppBootstrapCalls = async (page: Page) => {
+const mockAppBootstrapCalls = async (page: Page, isVersioningEnabled: boolean) => {
   for (const baseUrl of [BASE_API_URL, OLD_API_URL, PAYMENTS_API_URL]) {
     await page.route(`${baseUrl}/**`, (route) => route.fulfill({ json: {} }));
   }
 
-  for (const [path, body] of Object.entries(BOOTSTRAP_RESPONSES)) {
+  for (const [path, body] of Object.entries(buildBootstrapResponses(isVersioningEnabled))) {
     await page.route(`${BASE_API_URL}/${path}`, (route) => route.fulfill({ json: body }));
   }
 };
 
+const fulfillExistenceCheck = (route: Route, request: Request, drive: InMemoryDrive) => {
+  const url = request.url();
+  const folderUuid = firstCapture(FOLDER_CONTENT_UUID_PATTERN, url);
+
+  if (url.endsWith(FILES_EXISTENCE_PATH)) {
+    const { files } = request.postDataJSON() as ExistenceCheckRequest;
+    return route.fulfill({ json: { existentFiles: drive.existingFilesIn(folderUuid, files) } });
+  }
+  if (url.endsWith(FOLDERS_EXISTENCE_PATH)) {
+    const { plainNames } = request.postDataJSON() as FolderExistenceCheckRequest;
+    return route.fulfill({ json: { existentFolders: drive.existingFoldersIn(folderUuid, plainNames) } });
+  }
+  return route.fulfill({ json: NO_DUPLICATES });
+};
+
 const mockFolderContentRoutes = async (page: Page, drive: InMemoryDrive) => {
   const folderContentUrl = `${BASE_API_URL}/folders/content/**`;
 
   await page.route(folderContentUrl, (route, request) => {
     const url = request.url();
+    const folderUuid = firstCapture(FOLDER_CONTENT_UUID_PATTERN, url);
     const isFilesListing = url.includes(FILES_LISTING_PATH);
-    const files = drive.filesIn(firstCapture(FOLDER_CONTENT_UUID_PATTERN, url));
-    return route.fulfill({ json: isFilesListing ? { files } : { folders: [] } });
+    return route.fulfill({
+      json: isFilesListing ? { files: drive.filesIn(folderUuid) } : { folders: drive.foldersIn(folderUuid) },
+    });
   });
-  await mockRouteForMethod(page, folderContentUrl, HTTP_METHOD.post, (route) => route.fulfill({ json: NO_DUPLICATES }));
+  await mockRouteForMethod(page, folderContentUrl, HTTP_METHOD.post, (route, request) =>
+    fulfillExistenceCheck(route, request, drive),
+  );
+};
+
+const mockFolderNavigationRoutes = async (page: Page, drive: InMemoryDrive) => {
+  await mockRouteForMethod(page, `${BASE_API_URL}/folders/*/meta`, HTTP_METHOD.get, (route, request) =>
+    fulfillJsonIfFound(route, drive.findFolder(firstCapture(FOLDER_NAVIGATION_UUID_PATTERN, request.url()))),
+  );
+  await mockRouteForMethod(page, `${BASE_API_URL}/folders/*/ancestors`, HTTP_METHOD.get, (route, request) =>
+    route.fulfill({ json: drive.ancestorsOf(firstCapture(FOLDER_NAVIGATION_UUID_PATTERN, request.url())) }),
+  );
 };
 
 const mockFileEntryRoutes = async (page: Page, drive: InMemoryDrive, requests: RecordedRequests) => {
@@ -240,6 +438,59 @@ const mockFileEntryRoutes = async (page: Page, drive: InMemoryDrive, requests: R
   );
 };
 
+const mockCreateFolderRoute = (page: Page, drive: InMemoryDrive, requests: RecordedRequests) =>
+  mockRouteForMethod(page, `${BASE_API_URL}/folders`, HTTP_METHOD.post, (route, request) => {
+    const createFolderRequest = request.postDataJSON() as CreateFolderRequest;
+    requests.createdFolders.push(createFolderRequest);
+    return route.fulfill({ json: drive.createFolder(createFolderRequest) });
+  });
+
+const mockMoveFileRoute = (page: Page, drive: InMemoryDrive, requests: RecordedRequests) =>
+  mockRouteForMethod(page, `${BASE_API_URL}/files/*`, HTTP_METHOD.patch, (route, request) => {
+    const uuid = request.url().split('/').pop() ?? '';
+    const { destinationFolder, name } = request.postDataJSON() as Omit<MoveRequest, 'uuid'>;
+    const moveRequest: MoveRequest = name ? { uuid, destinationFolder, name } : { uuid, destinationFolder };
+    drive.moveFile(moveRequest);
+    requests.moves.push(moveRequest);
+    return route.fulfill({ json: {} });
+  });
+
+export const failMovesOf = async (page: Page, file: ExistingFile | TrashedFile): Promise<MoveRequest[]> => {
+  const rejectedMoves: MoveRequest[] = [];
+
+  await mockRouteForMethod(page, `${BASE_API_URL}/files/${file.uuid}`, HTTP_METHOD.patch, (route, request) => {
+    const { destinationFolder, name } = request.postDataJSON() as Omit<MoveRequest, 'uuid'>;
+    rejectedMoves.push({ uuid: file.uuid, destinationFolder, name });
+    return route.fulfill({ status: HTTP_INTERNAL_SERVER_ERROR, json: { message: 'Internal Server Error' } });
+  });
+
+  return rejectedMoves;
+};
+
+const mockReplaceFileRoute = (page: Page, requests: RecordedRequests) =>
+  mockRouteForMethod(page, `${BASE_API_URL}/files/*`, HTTP_METHOD.put, (route, request) => {
+    requests.replacedFileUuids.push(request.url().split('/').pop() ?? '');
+    return route.fulfill({ json: {} });
+  });
+
+const mockTrashRoute = (page: Page, drive: InMemoryDrive, requests: RecordedRequests) =>
+  mockRouteForMethod(page, `${BASE_API_URL}/storage/trash/add`, HTTP_METHOD.post, (route, request) => {
+    const trashRequest = request.postDataJSON() as TrashRequest;
+    drive.trash(trashRequest.items.map((item) => item.uuid));
+    requests.trash.push(trashRequest);
+    return route.fulfill({ json: {} });
+  });
+
+const mockTrashListingRoute = (page: Page, drive: InMemoryDrive) =>
+  page.route(`${BASE_API_URL}/storage/trash/paginated**`, (route, request) => {
+    const query = new URL(request.url()).searchParams;
+    if (query.get('type') !== 'files') return route.fulfill({ json: { result: [] } });
+
+    const offset = Number(query.get('offset') ?? 0);
+    const limit = Number(query.get('limit') ?? TRASH_PAGE_DEFAULT_LIMIT);
+    return route.fulfill({ json: { result: drive.trashedFilesPage(offset, limit) } });
+  });
+
 const fulfillBridgeCall = (route: Route, request: Request, bridge: InMemoryBridge, requests: RecordedRequests) => {
   const url = request.url();
   if (url.includes(START_UPLOAD_PATH)) return route.fulfill({ json: { uploads: [bridge.startUpload()] } });
@@ -274,13 +525,27 @@ const mockBridgeStorageRoutes = async (page: Page, requests: RecordedRequests) =
 };
 
 export const mockDriveRoutes = async (page: Page, options: MockedDriveOptions = {}): Promise<RecordedRequests> => {
-  const drive = new InMemoryDrive(options.declaredSizes);
-  const requests: RecordedRequests = { fileEntries: [], thumbnailEntries: [], downloadedFileIds: [] };
+  const drive = new InMemoryDrive(options);
+  const requests: RecordedRequests = {
+    fileEntries: [],
+    thumbnailEntries: [],
+    downloadedFileIds: [],
+    trash: [],
+    moves: [],
+    createdFolders: [],
+    replacedFileUuids: [],
+  };
 
-  await mockAppBootstrapCalls(page);
+  await mockAppBootstrapCalls(page, options.isVersioningEnabled ?? false);
   await mockAuthRoutes(page);
   await mockFolderContentRoutes(page, drive);
+  await mockFolderNavigationRoutes(page, drive);
   await mockFileEntryRoutes(page, drive, requests);
+  await mockCreateFolderRoute(page, drive, requests);
+  await mockMoveFileRoute(page, drive, requests);
+  await mockReplaceFileRoute(page, requests);
+  await mockTrashRoute(page, drive, requests);
+  await mockTrashListingRoute(page, drive);
   await mockBridgeStorageRoutes(page, requests);
 
   return requests;
diff --git a/test/e2e/tests/helper/mockedDrive.ts b/test/e2e/tests/helper/mockedDrive.ts
index 971a3afdf8..d3d0aba49c 100644
--- a/test/e2e/tests/helper/mockedDrive.ts
+++ b/test/e2e/tests/helper/mockedDrive.ts
@@ -1,11 +1,36 @@
-import { Page } from '@playwright/test';
-import { DrivePage } from '../pages/drivePage';
+import { expect, Page } from '@playwright/test';
+import { DrivePage, UploadFile } from '../pages/drivePage';
+import { NameCollisionDialogPage } from '../pages/nameCollisionDialogPage';
 import { logInThroughUI } from './authRouteMocks';
 import { MockedDriveOptions, mockDriveRoutes } from './driveRouteMocks';
 
+const FIRST_FILE_LISTED_TIMEOUT = 10000;
+const MIME_TYPES_BY_EXTENSION: Record<string, string> = {
+  txt: 'text/plain',
+  pdf: 'application/pdf',
+};
+
+export const buildUploadFile = (name: string): UploadFile => ({
+  name,
+  mimeType: MIME_TYPES_BY_EXTENSION[name.split('.').pop() ?? ''] ?? 'application/octet-stream',
+  buffer: Buffer.from(`content of ${name}`),
+});
+
+/**
+ * Mocks the API around the given Drive, logs in through the UI and, when the Drive has
+ * files, waits until the first one is listed.
+ */
 export const openMockedDrive = async (page: Page, options: MockedDriveOptions = {}) => {
   const requests = await mockDriveRoutes(page, options);
   await logInThroughUI(page);
 
-  return { drivePage: new DrivePage(page), requests };
+  const drivePage = new DrivePage(page);
+  const [firstFile] = options.files ?? [];
+  if (firstFile) {
+    await expect(drivePage.fileRow(`${firstFile.plainName}.${firstFile.type}`)).toBeVisible({
+      timeout: FIRST_FILE_LISTED_TIMEOUT,
+    });
+  }
+
+  return { drivePage, collisionDialog: new NameCollisionDialogPage(page), requests };
 };
diff --git a/test/e2e/tests/helper/staticData.ts b/test/e2e/tests/helper/staticData.ts
index 250f04610b..35cdfdc63d 100644
--- a/test/e2e/tests/helper/staticData.ts
+++ b/test/e2e/tests/helper/staticData.ts
@@ -47,4 +47,13 @@ export const staticData = {
   loadingPreviewText: 'Loading preview',
   downloadButtonText: 'Download',
   blobUrlPattern: /^blob:/,
+
+  //NAME COLLISION DIALOG
+  collisionDialogTitle: 'Item already exists',
+  collisionReplaceOption: 'Replace current item',
+  collisionKeepBothOption: 'Keep both',
+  collisionSkipOption: 'Skip this item',
+  collisionApplyToAll: 'Apply this action to all duplicates',
+
+  trashDisposalAnnouncementTitle: 'Automatic Trash disposal',
 };
diff --git a/test/e2e/tests/pages/drivePage.ts b/test/e2e/tests/pages/drivePage.ts
index f8d22c8c11..00268706b2 100644
--- a/test/e2e/tests/pages/drivePage.ts
+++ b/test/e2e/tests/pages/drivePage.ts
@@ -32,6 +32,13 @@ export class DrivePage {
   private uploadWidgetBorder: Locator;
   private fileInput: Locator;
   private movingToTrashAndMovedSign: Locator;
+  private folderInput: Locator;
+  private driveSidenavButton: Locator;
+  private trashSidenavButton: Locator;
+  private selectAllItemsCheckbox: Locator;
+  private restoreHeaderButton: Locator;
+  private trashDisposalAnnouncementTitle: Locator;
+  private trashDisposalAnnouncementCloseButton: Locator;
 
   constructor(page: Page) {
     this.page = page;
@@ -75,6 +82,20 @@ export class DrivePage {
     );
     this.uploadWidgetBorder = this.page.locator('[class$="border-b border-gray-10 bg-gray-5 px-3 py-2.5"]');
     this.fileInput = this.page.locator('[data-test="input-file"]');
+    this.folderInput = this.page.locator('[data-test="input-folder"]');
+    //SIDENAV
+    this.driveSidenavButton = this.page.locator('[data-cy="sideNavDriveIcon"]');
+    //TRASH
+    this.trashSidenavButton = this.page.locator('[data-cy="sideNavTrashIcon"]');
+    this.selectAllItemsCheckbox = this.page.locator('[data-cy="driveListHeaderCheckbox"]');
+    this.restoreHeaderButton = this.page.locator('[data-tooltip-content="Restore"]').getByRole('button');
+    this.trashDisposalAnnouncementTitle = this.page.getByRole('heading', {
+      name: staticData.trashDisposalAnnouncementTitle,
+    });
+    this.trashDisposalAnnouncementCloseButton = this.page
+      .getByRole('dialog')
+      .filter({ has: this.trashDisposalAnnouncementTitle })
+      .getByRole('button', { name: 'Close' });
   }
   async checkFolder(folderName: string) {
     const folderLocator = this.allFolderNamesInDrive.filter({ hasText: folderName });
@@ -201,6 +222,99 @@ export class DrivePage {
     await expect(thumbnail).toHaveAttribute('src', staticData.blobUrlPattern);
   }
 
+  async uploadFolder(directoryPath: string) {
+    await this.folderInput.setInputFiles(directoryPath);
+  }
+  itemRow(itemName: string) {
+    return this.page.locator('[data-test$="-parent"]', {
+      has: this.page.getByRole('button', { name: itemName, exact: true }),
+    });
+  }
+
+  async dragItemToFolder(itemName: string, folderName: string) {
+    const source = this.itemRow(itemName);
+    const dropZone = this.itemRow(folderName).locator('[data-test$="-drop-zone"]');
+    const dataTransfer = await this.page.evaluateHandle(() => new DataTransfer());
+
+    await source.dispatchEvent('dragstart', { dataTransfer });
+    await dropZone.dispatchEvent('dragenter', { dataTransfer });
+    await dropZone.dispatchEvent('dragover', { dataTransfer });
+    await dropZone.dispatchEvent('drop', { dataTransfer });
+    await source.dispatchEvent('dragend', { dataTransfer });
+  }
+
+  itemRows() {
+    return this.page.locator('[data-test$="-parent"]');
+  }
+
+  async expectListedItems(itemNames: string[]) {
+    for (const itemName of new Set(itemNames)) {
+      const expectedRows = itemNames.filter((name) => name === itemName).length;
+      await expect(this.itemRow(itemName)).toHaveCount(expectedRows, { timeout: 10000 });
+    }
+    await expect(this.itemRows()).toHaveCount(itemNames.length);
+  }
+
+  async openDrive() {
+    await this.driveSidenavButton.click();
+    await this.page.waitForURL((url) => url.pathname === '/');
+  }
+
+  async openFolder(folderName: string) {
+    const folderRow = this.itemRow(folderName);
+    const folderNameButton = folderRow.getByRole('button', { name: folderName, exact: true });
+
+    await folderRow.hover();
+    await folderNameButton.click();
+    await this.page.waitForURL('**/folder/**');
+  }
+
+  async openFolderFromDrive(folderName: string) {
+    await this.openDrive();
+    await this.openFolder(folderName);
+  }
+
+  async openTrash() {
+    await this.trashSidenavButton.click();
+    await this.page.waitForURL('**/trash');
+    await this.closeTrashDisposalAnnouncement();
+  }
+
+  async reopenTrash() {
+    await this.trashSidenavButton.click();
+    await this.page.waitForURL('**/trash');
+  }
+
+  async closeTrashDisposalAnnouncement() {
+    await expect(this.trashDisposalAnnouncementTitle).toBeVisible({ timeout: 10000 });
+    await this.trashDisposalAnnouncementCloseButton.click();
+    await expect(this.trashDisposalAnnouncementTitle).toBeHidden();
+  }
+
+  async selectAllItems() {
+    await this.selectAllItemsCheckbox.click();
+  }
+
+  async restoreSelectedItems() {
+    await expect(this.restoreHeaderButton).toBeVisible();
+    await this.restoreHeaderButton.click();
+  }
+
+  async restoreAllFromTrash(trashedItemNames: string[]) {
+    await this.openTrash();
+    await this.expectListedItems(trashedItemNames);
+    await this.selectAllItems();
+    await this.restoreSelectedItems();
+  }
+
+  fileRow(fileName: string) {
+    return this.page.locator(`[title="${fileName}"]`);
+  }
+
+  taskItem(itemName: string) {
+    return this.page.locator(`[data-test="task-logger"] [title="${itemName}"]`);
+  }
+
   private fileListElement(fileName: string, element: FileListElement) {
     return this.page.locator(`[data-test="file-list-file-${fileName}-${element}"]`);
   }
diff --git a/test/e2e/tests/pages/nameCollisionDialogPage.ts b/test/e2e/tests/pages/nameCollisionDialogPage.ts
new file mode 100644
index 0000000000..eb69494560
--- /dev/null
+++ b/test/e2e/tests/pages/nameCollisionDialogPage.ts
@@ -0,0 +1,72 @@
+import { expect, Locator, Page } from '@playwright/test';
+import { staticData } from '../helper/staticData';
+
+export class NameCollisionDialogPage {
+  private page: Page;
+  private dialog: Locator;
+  private title: Locator;
+  private options: Locator;
+  private applyToAllLabel: Locator;
+  private applyToAllCheckbox: Locator;
+  private submitButton: Locator;
+
+  constructor(page: Page) {
+    this.page = page;
+    this.dialog = this.page.getByRole('dialog');
+    this.title = this.dialog.getByText(staticData.collisionDialogTitle);
+    this.options = this.dialog.getByRole('radio');
+    this.applyToAllLabel = this.dialog.getByText(staticData.collisionApplyToAll);
+    this.applyToAllCheckbox = this.dialog.locator('#apply-to-all');
+    this.submitButton = this.dialog.getByRole('button', { name: /^(Upload|Move)$/ });
+  }
+
+  async expectOpenFor(itemName: string) {
+    await expect(this.title).toBeVisible({ timeout: 10000 });
+    await expect(this.dialog.getByText(`${itemName} already exists in this location`)).toBeVisible();
+  }
+
+  async expectClosed() {
+    await expect(this.title).toBeHidden({ timeout: 10000 });
+  }
+
+  async expectOptions(optionNames: string[]) {
+    await expect(this.options).toHaveText(optionNames);
+  }
+
+  async expectApplyToAllVisible(isVisible: boolean) {
+    await expect(this.applyToAllLabel).toBeVisible({ visible: isVisible });
+  }
+
+  /** Between two same-name items the dialog text does not change: only "apply to all" disappears. */
+  async expectReadyForLastItem() {
+    await expect(this.applyToAllLabel).toBeHidden({ timeout: 10000 });
+    await expect(this.title).toBeVisible();
+    await expect(this.submitButton).toBeEnabled();
+  }
+
+  async selectOption(optionName: string) {
+    await this.dialog.getByRole('radio', { name: optionName }).click();
+  }
+
+  async checkApplyToAllByClickingLabel() {
+    await this.applyToAllLabel.click();
+    await expect(this.applyToAllCheckbox).toBeChecked();
+  }
+
+  async submit() {
+    await expect(this.submitButton).toBeVisible();
+    await this.submitButton.click();
+  }
+
+  async resolve(itemName: string, optionName: string) {
+    await this.expectOpenFor(itemName);
+    await this.selectOption(optionName);
+    await this.submit();
+  }
+
+  async resolveLastItem(optionName: string) {
+    await this.expectReadyForLastItem();
+    await this.selectOption(optionName);
+    await this.submit();
+  }
+}
diff --git a/test/e2e/tests/specs/DRIVE-internxt-name-collision-resolutions.spec.ts b/test/e2e/tests/specs/DRIVE-internxt-name-collision-resolutions.spec.ts
new file mode 100644
index 0000000000..bbb82cf8c1
--- /dev/null
+++ b/test/e2e/tests/specs/DRIVE-internxt-name-collision-resolutions.spec.ts
@@ -0,0 +1,387 @@
+import { expect, test } from '@playwright/test';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import {
+  buildExistingFile,
+  buildExistingFolder,
+  buildTrashedFile,
+  failMovesOf,
+  MoveRequest,
+  ROOT_FOLDER_UUID,
+  TrashedFile,
+  TrashRequest,
+} from '../helper/driveRouteMocks';
+import { buildUploadFile, openMockedDrive } from '../helper/mockedDrive';
+import { staticData } from '../helper/staticData';
+import { DrivePage } from '../pages/drivePage';
+
+const archive = buildExistingFolder(1, 'Archive');
+const photos = buildExistingFolder(2, 'Photos');
+const rootReport = buildExistingFile(1, 'report', 'txt');
+const invoice = buildExistingFile(2, 'invoice', 'pdf');
+const archivedReport = buildExistingFile(3, 'report', 'txt', archive.uuid);
+const existingDrive = {
+  files: [rootReport, invoice, archivedReport, buildExistingFile(4, 'a', 'txt', photos.uuid)],
+  folders: [archive, photos, buildExistingFolder(3, 'Sub', photos.uuid)],
+};
+
+const archivedOther = buildExistingFile(5, 'other', 'txt', archive.uuid);
+const trashedReport = buildTrashedFile(10, 'report', 'txt', archive.uuid);
+const trashedReportCopy = buildTrashedFile(11, 'report', 'txt', archive.uuid);
+const trashedOther = buildTrashedFile(12, 'other', 'txt', archive.uuid);
+
+/**
+ * Archive holds report.txt and other.txt; the trash holds two report.txt and one other.txt deleted from it.
+ * Versioning is on only to keep the Playwright UI snapshots clean (see runbook §9, "Locked feature").
+ */
+const driveWithTrash = {
+  files: [...existingDrive.files, archivedOther],
+  folders: existingDrive.folders,
+  trashedFiles: [trashedReport, trashedReportCopy, trashedOther],
+  isVersioningEnabled: true,
+};
+
+/** Archive holds one report.txt; the trash holds two report.txt deleted from it and nothing else collides. */
+const driveWithSameNameTrash = {
+  ...driveWithTrash,
+  files: existingDrive.files,
+  trashedFiles: [trashedReport, trashedReportCopy],
+};
+
+const getTrashedUuids = (trashRequests: TrashRequest[]) =>
+  trashRequests.flatMap((trashRequest) => trashRequest.items.map((item) => item.uuid));
+
+const archivedReportTrashedOnce: TrashRequest[] = [{ items: [{ uuid: archivedReport.uuid, type: 'file' }] }];
+
+const buildMoveToArchive = (trashedFile: TrashedFile, newName?: string): MoveRequest => {
+  const move = { uuid: trashedFile.uuid, destinationFolder: archive.uuid };
+  return newName ? { ...move, name: newName } : move;
+};
+
+/** Reloads both lists from the server the way a user would: Drive → Archive, then back to the trash. */
+const expectArchiveAndTrash = async (
+  drivePage: DrivePage,
+  { archiveItems, trashItems }: { archiveItems: string[]; trashItems: string[] },
+) => {
+  await drivePage.openFolderFromDrive(archive.plainName);
+  await drivePage.expectListedItems(archiveItems);
+
+  await drivePage.reopenTrash();
+  await drivePage.expectListedItems(trashItems);
+};
+
+/**
+ * A local "Photos" folder that partially overlaps with the existing one:
+ * Photos/a.txt (exists), Photos/b.txt (new), Photos/Sub/c.txt (Sub exists, c.txt is new),
+ * Photos/New/d.txt (New is new).
+ */
+const createPhotosDirectory = () => {
+  const root = mkdtempSync(join(tmpdir(), 'collision-'));
+  const photosPath = join(root, 'Photos');
+  mkdirSync(join(photosPath, 'Sub'), { recursive: true });
+  mkdirSync(join(photosPath, 'New'), { recursive: true });
+  writeFileSync(join(photosPath, 'a.txt'), 'a');
+  writeFileSync(join(photosPath, 'b.txt'), 'b');
+  writeFileSync(join(photosPath, 'Sub', 'c.txt'), 'c');
+  writeFileSync(join(photosPath, 'New', 'd.txt'), 'd');
+  return { root, photosPath };
+};
+
+test.describe('Internxt name collision resolutions', () => {
+  test.use({ storageState: { cookies: [], origins: [] } });
+
+  test('TC1: Validate that keeping both on a duplicated file uploads it under a numbered name', async ({ page }) => {
+    const { drivePage, collisionDialog, requests } = await openMockedDrive(page, existingDrive);
+
+    await drivePage.uploadFiles([buildUploadFile('report.txt')]);
+    await collisionDialog.resolve('report.txt', staticData.collisionKeepBothOption);
+
+    await expect(drivePage.taskItem('report (1).txt')).toBeVisible({ timeout: 10000 });
+    await collisionDialog.expectClosed();
+    expect(requests.trash).toHaveLength(0);
+  });
+
+  test.describe('Folder uploads', () => {
+    let directory: ReturnType<typeof createPhotosDirectory>;
+
+    test.beforeAll(() => {
+      directory = createPhotosDirectory();
+    });
+
+    test.afterAll(() => {
+      rmSync(directory.root, { recursive: true, force: true });
+    });
+
+    test('TC2: Validate that keeping both on a duplicated folder creates it under a numbered name', async ({
+      page,
+    }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, existingDrive);
+
+      await drivePage.uploadFolder(directory.photosPath);
+      await collisionDialog.resolve('Photos', staticData.collisionKeepBothOption);
+
+      await expect
+        .poll(() => requests.createdFolders, { timeout: 10000 })
+        .toContainEqual({
+          plainName: 'Photos (1)',
+          parentFolderUuid: ROOT_FOLDER_UUID,
+        });
+      expect(requests.trash).toHaveLength(0);
+    });
+
+    test('TC3: Validate that replacing a duplicated folder trashes the existing one before creating the new one', async ({
+      page,
+    }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, existingDrive);
+
+      await drivePage.uploadFolder(directory.photosPath);
+      await collisionDialog.resolve('Photos', staticData.collisionReplaceOption);
+
+      await expect
+        .poll(() => requests.createdFolders, { timeout: 10000 })
+        .toContainEqual({
+          plainName: 'Photos',
+          parentFolderUuid: ROOT_FOLDER_UUID,
+        });
+      expect(requests.trash).toEqual([{ items: [{ uuid: photos.uuid, type: 'folder' }] }]);
+    });
+
+    test('TC4: Validate that skipping a duplicated folder merges only its new content into the existing folder', async ({
+      page,
+    }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, existingDrive);
+
+      await drivePage.uploadFolder(directory.photosPath);
+      await collisionDialog.resolve('Photos', staticData.collisionSkipOption);
+
+      await expect(drivePage.taskItem('b.txt')).toBeVisible({ timeout: 10000 });
+      await expect(drivePage.taskItem('c.txt')).toBeVisible({ timeout: 10000 });
+      await expect
+        .poll(() => requests.createdFolders, { timeout: 10000 })
+        .toEqual([{ plainName: 'New', parentFolderUuid: photos.uuid }]);
+      await expect(drivePage.taskItem('a.txt')).toHaveCount(0);
+      expect(requests.trash).toHaveLength(0);
+    });
+  });
+
+  test.describe('Move collisions', () => {
+    test('TC5: Validate that replacing a moved file trashes the file it collides with in the destination', async ({
+      page,
+    }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, existingDrive);
+
+      await drivePage.dragItemToFolder('report.txt', 'Archive');
+      await collisionDialog.resolve('report', staticData.collisionReplaceOption);
+
+      await collisionDialog.expectClosed();
+      await expect
+        .poll(() => requests.moves, { timeout: 10000 })
+        .toEqual([{ uuid: rootReport.uuid, destinationFolder: archive.uuid }]);
+      expect(requests.trash).toEqual([{ items: [{ uuid: archivedReport.uuid, type: 'file' }] }]);
+    });
+
+    test('TC6: Validate that keeping both on a moved file moves it under a numbered name', async ({ page }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, existingDrive);
+
+      await drivePage.dragItemToFolder('report.txt', 'Archive');
+      await collisionDialog.resolve('report', staticData.collisionKeepBothOption);
+
+      await collisionDialog.expectClosed();
+      await expect
+        .poll(() => requests.moves, { timeout: 10000 })
+        .toEqual([{ uuid: rootReport.uuid, destinationFolder: archive.uuid, name: 'report (1)' }]);
+      expect(requests.trash).toHaveLength(0);
+    });
+
+    test('TC7: Validate that skipping a moved file leaves both files where they are', async ({ page }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, existingDrive);
+
+      await drivePage.dragItemToFolder('report.txt', 'Archive');
+      await collisionDialog.resolve('report', staticData.collisionSkipOption);
+
+      await collisionDialog.expectClosed();
+      await expect(drivePage.fileRow('report.txt')).toHaveCount(1);
+      expect(requests.moves).toHaveLength(0);
+      expect(requests.trash).toHaveLength(0);
+    });
+  });
+
+  test('TC8: Validate that replacing a versionable file uploads a new version instead of trashing it', async ({
+    page,
+    browserName,
+  }) => {
+    test.skip(browserName !== 'chromium', 'Bridge requests can only be intercepted in Chromium');
+    const { drivePage, collisionDialog, requests } = await openMockedDrive(page, {
+      ...existingDrive,
+      isVersioningEnabled: true,
+    });
+
+    await drivePage.uploadFiles([buildUploadFile('invoice.pdf')]);
+    await collisionDialog.resolve('invoice.pdf', staticData.collisionReplaceOption);
+
+    await expect.poll(() => requests.replacedFileUuids, { timeout: 15000 }).toEqual([invoice.uuid]);
+    expect(requests.trash).toHaveLength(0);
+  });
+
+  test.describe('Restore collisions', () => {
+    test('TC9: Validate that keeping both on every restored file gives each same-name file its own numbered name', async ({
+      page,
+    }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, driveWithTrash);
+
+      await drivePage.openTrash();
+      await expect(drivePage.fileRow('report.txt')).toHaveCount(2);
+      await drivePage.selectAllItems();
+      await drivePage.restoreSelectedItems();
+
+      await collisionDialog.expectOpenFor('report');
+      await collisionDialog.checkApplyToAllByClickingLabel();
+      await collisionDialog.selectOption(staticData.collisionKeepBothOption);
+      await collisionDialog.submit();
+
+      await collisionDialog.expectClosed();
+      await expect.poll(() => requests.moves, { timeout: 10000 }).toHaveLength(3);
+      expect(requests.moves).toEqual(
+        expect.arrayContaining([
+          { uuid: trashedReport.uuid, destinationFolder: archive.uuid, name: 'report (1)' },
+          { uuid: trashedReportCopy.uuid, destinationFolder: archive.uuid, name: 'report (2)' },
+          { uuid: trashedOther.uuid, destinationFolder: archive.uuid, name: 'other (1)' },
+        ]),
+      );
+      expect(requests.trash).toHaveLength(0);
+      await drivePage.expectListedItems([]);
+
+      await drivePage.openFolderFromDrive(archive.plainName);
+      await drivePage.expectListedItems([
+        'report.txt',
+        'report (1).txt',
+        'report (2).txt',
+        'other.txt',
+        'other (1).txt',
+      ]);
+    });
+
+    test('TC10: Validate that replacing with every restored file trashes each existing file once and keeps the second same-name file under a numbered name', async ({
+      page,
+    }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, driveWithTrash);
+
+      await drivePage.openTrash();
+      await expect(drivePage.fileRow('report.txt')).toHaveCount(2);
+      await drivePage.selectAllItems();
+      await drivePage.restoreSelectedItems();
+
+      await collisionDialog.expectOpenFor('report');
+      await collisionDialog.checkApplyToAllByClickingLabel();
+      await collisionDialog.selectOption(staticData.collisionReplaceOption);
+      await collisionDialog.submit();
+
+      await collisionDialog.expectClosed();
+      await expect.poll(() => requests.moves, { timeout: 10000 }).toHaveLength(3);
+
+      const trashedUuids = getTrashedUuids(requests.trash);
+      expect(trashedUuids).toHaveLength(2);
+      expect(trashedUuids).toEqual(expect.arrayContaining([archivedReport.uuid, archivedOther.uuid]));
+
+      const [firstMove, secondMove, lastMove] = requests.moves;
+      expect([firstMove, secondMove]).toEqual(
+        expect.arrayContaining([
+          { uuid: trashedReport.uuid, destinationFolder: archive.uuid },
+          { uuid: trashedOther.uuid, destinationFolder: archive.uuid },
+        ]),
+      );
+      expect(lastMove).toEqual({ uuid: trashedReportCopy.uuid, destinationFolder: archive.uuid, name: 'report (1)' });
+      await drivePage.expectListedItems([]);
+
+      await drivePage.openFolderFromDrive(archive.plainName);
+      await drivePage.expectListedItems(['report.txt', 'report (1).txt', 'other.txt']);
+
+      await drivePage.reopenTrash();
+      await drivePage.expectListedItems(['report.txt', 'other.txt']);
+    });
+
+    test('TC11: Validate that a restored file whose move fails stays in the trash while the moved one leaves it', async ({
+      page,
+    }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, {
+        ...driveWithTrash,
+        trashedFiles: [trashedReport, trashedOther],
+      });
+      const rejectedMoves = await failMovesOf(page, trashedOther);
+
+      await drivePage.openTrash();
+      await expect(drivePage.fileRow('report.txt')).toHaveCount(1);
+      await expect(drivePage.fileRow('other.txt')).toHaveCount(1);
+      await drivePage.selectAllItems();
+      await drivePage.restoreSelectedItems();
+
+      await collisionDialog.expectOpenFor('report');
+      await collisionDialog.checkApplyToAllByClickingLabel();
+      await collisionDialog.selectOption(staticData.collisionKeepBothOption);
+      await collisionDialog.submit();
+
+      await collisionDialog.expectClosed();
+      await expect
+        .poll(() => rejectedMoves, { timeout: 10000 })
+        .toEqual([{ uuid: trashedOther.uuid, destinationFolder: archive.uuid, name: 'other (1)' }]);
+      await drivePage.expectListedItems(['other.txt']);
+      expect(requests.moves).toEqual([
+        { uuid: trashedReport.uuid, destinationFolder: archive.uuid, name: 'report (1)' },
+      ]);
+
+      await drivePage.openFolderFromDrive(archive.plainName);
+      await drivePage.expectListedItems(['report.txt', 'report (1).txt', 'other.txt']);
+      await expect(drivePage.itemRow('other (1).txt')).toHaveCount(0);
+    });
+
+    test('TC12: Validate that replacing with two same-name restored files one at a time trashes the existing file only once', async ({
+      page,
+    }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, driveWithSameNameTrash);
+      const replacingMove = buildMoveToArchive(trashedReport);
+      const numberedMove = buildMoveToArchive(trashedReportCopy, 'report (1)');
+
+      await drivePage.restoreAllFromTrash(['report.txt', 'report.txt']);
+      await collisionDialog.expectApplyToAllVisible(true);
+      await collisionDialog.resolve('report', staticData.collisionReplaceOption);
+      await expect.poll(() => requests.moves, { timeout: 10000 }).toEqual([replacingMove]);
+      expect(requests.trash).toEqual(archivedReportTrashedOnce);
+
+      await collisionDialog.resolveLastItem(staticData.collisionReplaceOption);
+      await collisionDialog.expectClosed();
+      await expect.poll(() => requests.moves, { timeout: 10000 }).toEqual([replacingMove, numberedMove]);
+      expect(requests.trash).toEqual(archivedReportTrashedOnce);
+
+      await drivePage.expectListedItems([]);
+      await expectArchiveAndTrash(drivePage, {
+        archiveItems: ['report.txt', 'report (1).txt'],
+        trashItems: ['report.txt'],
+      });
+    });
+
+    test('TC13: Validate that replacing after keeping both on a same-name restored file still trashes the existing file', async ({
+      page,
+    }) => {
+      const { drivePage, collisionDialog, requests } = await openMockedDrive(page, driveWithSameNameTrash);
+      const numberedMove = buildMoveToArchive(trashedReport, 'report (1)');
+      const replacingMove = buildMoveToArchive(trashedReportCopy);
+
+      await drivePage.restoreAllFromTrash(['report.txt', 'report.txt']);
+      await collisionDialog.resolve('report', staticData.collisionKeepBothOption);
+      await expect.poll(() => requests.moves, { timeout: 10000 }).toEqual([numberedMove]);
+      expect(requests.trash).toHaveLength(0);
+
+      await collisionDialog.resolveLastItem(staticData.collisionReplaceOption);
+      await collisionDialog.expectClosed();
+      await expect.poll(() => requests.moves, { timeout: 10000 }).toEqual([numberedMove, replacingMove]);
+      expect(requests.trash).toEqual(archivedReportTrashedOnce);
+
+      await drivePage.expectListedItems([]);
+      await expectArchiveAndTrash(drivePage, {
+        archiveItems: ['report.txt', 'report (1).txt'],
+        trashItems: ['report.txt'],
+      });
+    });
+  });
+});
diff --git a/test/e2e/tests/specs/DRIVE-internxt-name-collision-skip.spec.ts b/test/e2e/tests/specs/DRIVE-internxt-name-collision-skip.spec.ts
new file mode 100644
index 0000000000..ec5e451a1e
--- /dev/null
+++ b/test/e2e/tests/specs/DRIVE-internxt-name-collision-skip.spec.ts
@@ -0,0 +1,109 @@
+import { expect, test } from '@playwright/test';
+import { buildExistingFile } from '../helper/driveRouteMocks';
+import { buildUploadFile, openMockedDrive } from '../helper/mockedDrive';
+import { staticData } from '../helper/staticData';
+
+const existingReport = buildExistingFile(1, 'report', 'txt');
+const existingInvoice = buildExistingFile(2, 'invoice', 'pdf');
+
+const duplicatedReport = buildUploadFile('report.txt');
+const duplicatedInvoice = buildUploadFile('invoice.pdf');
+const newFile = buildUploadFile('brand-new.txt');
+
+const allOptions = [
+  staticData.collisionReplaceOption,
+  staticData.collisionKeepBothOption,
+  staticData.collisionSkipOption,
+];
+
+test.describe('Internxt name collision skip option', () => {
+  test.use({ storageState: { cookies: [], origins: [] } });
+
+  let drive: Awaited<ReturnType<typeof openMockedDrive>>;
+
+  test.beforeEach('Logging in with existing files in Drive', async ({ page }) => {
+    drive = await openMockedDrive(page, { files: [existingReport, existingInvoice] });
+  });
+
+  test('TC1: Validate that skipping a single duplicated file keeps the existing file and uploads nothing', async () => {
+    const { drivePage, collisionDialog, requests } = drive;
+
+    await drivePage.uploadFiles([duplicatedReport]);
+
+    await collisionDialog.expectOpenFor('report.txt');
+    await collisionDialog.expectOptions(allOptions);
+    await collisionDialog.expectApplyToAllVisible(false);
+
+    await collisionDialog.selectOption(staticData.collisionSkipOption);
+    await collisionDialog.submit();
+
+    await collisionDialog.expectClosed();
+    await expect(drivePage.fileRow('report.txt')).toHaveCount(1);
+    expect(requests.trash).toHaveLength(0);
+    expect(requests.fileEntries).toHaveLength(0);
+  });
+
+  test('TC2: Validate that only the non-conflicting files are uploaded when the duplicated one is skipped', async () => {
+    const { drivePage, collisionDialog, requests } = drive;
+
+    await drivePage.uploadFiles([duplicatedReport, newFile]);
+
+    await collisionDialog.expectOpenFor('report.txt');
+    await expect(drivePage.taskItem('brand-new.txt')).toBeVisible({ timeout: 10000 });
+
+    await collisionDialog.selectOption(staticData.collisionSkipOption);
+    await collisionDialog.submit();
+
+    await collisionDialog.expectClosed();
+    expect(requests.trash).toHaveLength(0);
+  });
+
+  test('TC3: Validate that duplicated files are resolved one by one when "apply to all" is not checked', async () => {
+    const { drivePage, collisionDialog, requests } = drive;
+
+    await drivePage.uploadFiles([duplicatedReport, duplicatedInvoice]);
+
+    await collisionDialog.expectOpenFor('report.txt');
+    await collisionDialog.expectApplyToAllVisible(true);
+    await collisionDialog.selectOption(staticData.collisionSkipOption);
+    await collisionDialog.submit();
+
+    await collisionDialog.expectOpenFor('invoice.pdf');
+    await collisionDialog.expectApplyToAllVisible(false);
+    await collisionDialog.selectOption(staticData.collisionSkipOption);
+    await collisionDialog.submit();
+
+    await collisionDialog.expectClosed();
+    expect(requests.trash).toHaveLength(0);
+    expect(requests.fileEntries).toHaveLength(0);
+  });
+
+  test('TC4: Validate that "apply to all" skips every duplicated file at once and closes the dialog', async () => {
+    const { drivePage, collisionDialog, requests } = drive;
+
+    await drivePage.uploadFiles([duplicatedReport, duplicatedInvoice]);
+
+    await collisionDialog.expectOpenFor('report.txt');
+    await collisionDialog.checkApplyToAllByClickingLabel();
+    await collisionDialog.selectOption(staticData.collisionSkipOption);
+    await collisionDialog.submit();
+
+    await collisionDialog.expectClosed();
+    await expect(drivePage.fileRow('report.txt')).toHaveCount(1);
+    await expect(drivePage.fileRow('invoice.pdf')).toHaveCount(1);
+    expect(requests.trash).toHaveLength(0);
+    expect(requests.fileEntries).toHaveLength(0);
+  });
+
+  test('TC5: Validate that replacing a duplicated file sends its matching existing file to trash', async () => {
+    const { drivePage, collisionDialog, requests } = drive;
+
+    await drivePage.uploadFiles([duplicatedInvoice]);
+    await collisionDialog.resolve('invoice.pdf', staticData.collisionReplaceOption);
+
+    await expect
+      .poll(() => requests.trash, { timeout: 10000 })
+      .toEqual([{ items: [{ uuid: existingInvoice.uuid, type: 'file' }] }]);
+    await collisionDialog.expectClosed();
+  });
+});
diff --git a/test/e2e/tests/specs/internxt-login.spec.ts b/test/e2e/tests/specs/internxt-login.spec.ts
index 21ec5fbfa8..a8f50a8e02 100644
--- a/test/e2e/tests/specs/internxt-login.spec.ts
+++ b/test/e2e/tests/specs/internxt-login.spec.ts
@@ -1,54 +1,17 @@
-import { expect, Request, Route, test } from '@playwright/test';
-import { getLoggedUser, getUserCredentials } from '../helper/getUser';
+import { expect, test } from '@playwright/test';
+import { INVALID_EMAIL, mockAuthRoutes } from '../helper/authRouteMocks';
+import { getUserCredentials } from '../helper/getUser';
 import { staticData } from '../helper/staticData';
 import { LoginPage } from '../pages/loginPage';
-const BASE_API_URL = process.env.REACT_APP_DRIVE_NEW_API_URL;
 
 const credentialsFile = getUserCredentials();
-const user = getLoggedUser();
-const invalidEmail = 'invalid@internxt.com';
-
-const mockLoginCall = async (route: Route, request: Request) => {
-  await route.fulfill({
-    status: 200,
-    contentType: 'application/json',
-    body: JSON.stringify({
-      hasKeys: true,
-      sKey: '53616c7465645f5f2aa5386bc0b15f6f69a733acdd46a6551dc004f6c1cb6352390535de3ec17e9b96da7de984e5d27e79ad04a88a2cc8c6315f03dc0b0d174c',
-      tfa: false,
-      hasKyberKeys: true,
-      hasEccKeys: true,
-    }),
-  });
-};
-
-const mockAccessCall = async (route: Route, request: Request) => {
-  const { email } = request.postDataJSON();
-
-  if (invalidEmail === email) {
-    return route.fulfill({
-      status: 400,
-      body: JSON.stringify({ message: 'Wrong login credentials' }),
-    });
-  }
-
-  await route.fulfill({
-    status: 200,
-    body: JSON.stringify({
-      user: user.user,
-      token: user.token,
-      newToken: user.newToken,
-      userTeam: user.userTeam,
-    }),
-  });
-};
+const invalidEmail = INVALID_EMAIL;
 
 test.describe('internxt login', async () => {
   test.use({ storageState: { cookies: [], origins: [] } });
 
   test.beforeEach('Visiting Internxt', async ({ page }) => {
-    await page.route(`${BASE_API_URL}/auth/login`, mockLoginCall);
-    await page.route(`${BASE_API_URL}/auth/login/access`, mockAccessCall);
+    await mockAuthRoutes(page);
 
     await page.goto('/');
     await expect(page).toHaveURL('http://localhost:3000/login');