diff --git a/Files/Files.csproj b/Files/Files.csproj
index e4fdd9cac6f4..07661e23f7fc 100644
--- a/Files/Files.csproj
+++ b/Files/Files.csproj
@@ -29,6 +29,7 @@
     <AppxBundlePlatforms>x86|x64|arm|arm64</AppxBundlePlatforms>
     <HoursBetweenUpdateChecks>0</HoursBetweenUpdateChecks>
     <Win32Resource>Resources\MiddleClickScrolling-CursorType.res</Win32Resource>
+    <LangVersion>9.0</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
     <DebugSymbols>true</DebugSymbols>
@@ -40,7 +41,6 @@
     <UseVSHostingProcess>false</UseVSHostingProcess>
     <ErrorReport>prompt</ErrorReport>
     <Prefer32Bit>true</Prefer32Bit>
-    <LangVersion>9.0</LangVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <UseDotNetNativeToolchain>false</UseDotNetNativeToolchain>
     <UseAppLocalCoreFramework>true</UseAppLocalCoreFramework>
@@ -56,7 +56,6 @@
     <ErrorReport>prompt</ErrorReport>
     <Prefer32Bit>true</Prefer32Bit>
     <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
-    <LangVersion>9.0</LangVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|ARM'">
@@ -69,7 +68,6 @@
     <UseVSHostingProcess>false</UseVSHostingProcess>
     <ErrorReport>prompt</ErrorReport>
     <Prefer32Bit>true</Prefer32Bit>
-    <LangVersion>9.0</LangVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <UseAppLocalCoreFramework>true</UseAppLocalCoreFramework>
   </PropertyGroup>
@@ -84,7 +82,6 @@
     <ErrorReport>prompt</ErrorReport>
     <Prefer32Bit>true</Prefer32Bit>
     <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
-    <LangVersion>9.0</LangVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|ARM64'">
@@ -98,7 +95,6 @@
     <ErrorReport>prompt</ErrorReport>
     <Prefer32Bit>true</Prefer32Bit>
     <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
-    <LangVersion>9.0</LangVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <UseAppLocalCoreFramework>true</UseAppLocalCoreFramework>
   </PropertyGroup>
@@ -113,7 +109,6 @@
     <ErrorReport>prompt</ErrorReport>
     <Prefer32Bit>true</Prefer32Bit>
     <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
-    <LangVersion>9.0</LangVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
@@ -126,7 +121,6 @@
     <UseVSHostingProcess>false</UseVSHostingProcess>
     <ErrorReport>prompt</ErrorReport>
     <Prefer32Bit>true</Prefer32Bit>
-    <LangVersion>9.0</LangVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <UseAppLocalCoreFramework>true</UseAppLocalCoreFramework>
   </PropertyGroup>
@@ -141,7 +135,6 @@
     <ErrorReport>prompt</ErrorReport>
     <Prefer32Bit>true</Prefer32Bit>
     <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
-    <LangVersion>9.0</LangVersion>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup>
@@ -423,9 +416,6 @@
     <Compile Include="Filesystem\Search\FolderSearch.cs" />
     <Compile Include="Filesystem\StorageFileHelpers\FilesystemResult.cs" />
     <Compile Include="Filesystem\StorageFileHelpers\StorageFileExtensions.cs" />
-    <Compile Include="Filesystem\StorageFileHelpers\IStorageItemWithPath.cs" />
-    <Compile Include="Filesystem\StorageFileHelpers\StorageFileWithPath.cs" />
-    <Compile Include="Filesystem\StorageFileHelpers\StorageFolderWithPath.cs" />
     <Compile Include="Filesystem\StorageHistory\Helpers\StorageHistoryHelpers.cs" />
     <Compile Include="Filesystem\StorageHistory\IStorageHistory.cs" />
     <Compile Include="Filesystem\StorageHistory\IStorageHistoryOperations.cs" />
diff --git a/Files/Filesystem/Drives.cs b/Files/Filesystem/Drives.cs
index e149bcf336bb..69efe00fbfa9 100644
--- a/Files/Filesystem/Drives.cs
+++ b/Files/Filesystem/Drives.cs
@@ -384,7 +384,7 @@ private DriveType GetDriveType(DriveInfo drive)
             return type;
         }
 
-        public static async Task<StorageFolderWithPath> GetRootFromPathAsync(string devicePath)
+        public static async Task<IStorageFolder> GetRootFromPathAsync(string devicePath)
         {
             if (!Path.IsPathRooted(devicePath))
             {
@@ -419,13 +419,13 @@ public static async Task<StorageFolderWithPath> GetRootFromPathAsync(string devi
                 }
                 if (matchingDrive != null)
                 {
-                    return new StorageFolderWithPath(matchingDrive, rootPath);
+                    return matchingDrive;
                 }
             }
             else if (devicePath.StartsWith("\\\\")) // Network share
             {
                 rootPath = rootPath.LastIndexOf("\\") > 1 ? rootPath.Substring(0, rootPath.LastIndexOf("\\")) : rootPath; // Remove share name
-                return new StorageFolderWithPath(await StorageFolder.GetFolderFromPathAsync(rootPath), rootPath);
+                return await StorageFolder.GetFolderFromPathAsync(rootPath);
             }
             // It's ok to return null here, on normal drives StorageFolder.GetFolderFromPathAsync works
             return null;
diff --git a/Files/Filesystem/FilesystemOperations/FilesystemOperations.cs b/Files/Filesystem/FilesystemOperations/FilesystemOperations.cs
index 29f9c59958ae..d5c9e6c4b28c 100644
--- a/Files/Filesystem/FilesystemOperations/FilesystemOperations.cs
+++ b/Files/Filesystem/FilesystemOperations/FilesystemOperations.cs
@@ -50,14 +50,14 @@ public FilesystemOperations(IShellPage associatedInstance)
 
         #region IFilesystemOperations
 
-        public async Task<(IStorageHistory, IStorageItem)> CreateAsync(IStorageItemWithPath source, IProgress<FileSystemStatusCode> errorCode, CancellationToken cancellationToken)
+        public async Task<(IStorageHistory, IStorageItem)> CreateAsync(IStorageItem source, IProgress<FileSystemStatusCode> errorCode, CancellationToken cancellationToken)
         {
             IStorageItem item = null;
             try
             {
-                switch (source.ItemType)
+                switch (source)
                 {
-                    case FilesystemItemType.File:
+                    case IStorageFile:
                         {
                             var newEntryInfo = await RegistryHelper.GetNewContextMenuEntryForType(Path.GetExtension(source.Path));
                             if (newEntryInfo == null)
@@ -73,7 +73,7 @@ public FilesystemOperations(IShellPage associatedInstance)
                             break;
                         }
 
-                    case FilesystemItemType.Directory:
+                    case IStorageFolder:
                         {
                             StorageFolder folder = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(Path.GetDirectoryName(source.Path));
                             item = await folder.CreateFolderAsync(Path.GetFileName(source.Path));
@@ -81,12 +81,6 @@ public FilesystemOperations(IShellPage associatedInstance)
                             break;
                         }
 
-                    case FilesystemItemType.Symlink:
-                        {
-                            Debugger.Break();
-                            throw new NotImplementedException();
-                        }
-
                     default:
                         Debugger.Break();
                         break;
@@ -108,21 +102,6 @@ public async Task<IStorageHistory> CopyAsync(IStorageItem source,
                                                      IProgress<float> progress,
                                                      IProgress<FileSystemStatusCode> errorCode,
                                                      CancellationToken cancellationToken)
-        {
-            return await CopyAsync(source.FromStorageItem(),
-                                                    destination,
-                                                    collision,
-                                                    progress,
-                                                    errorCode,
-                                                    cancellationToken);
-        }
-
-        public async Task<IStorageHistory> CopyAsync(IStorageItemWithPath source,
-                                                     string destination,
-                                                     NameCollisionOption collision,
-                                                     IProgress<float> progress,
-                                                     IProgress<FileSystemStatusCode> errorCode,
-                                                     CancellationToken cancellationToken)
         {
             if (destination.StartsWith(App.AppSettings.RecycleBinPath))
             {
@@ -139,7 +118,7 @@ await DialogDisplayHelper.ShowDialogAsync(
             IStorageItem copiedItem = null;
             //long itemSize = await FilesystemHelpers.GetItemSize(await source.ToStorageItem(associatedInstance));
 
-            if (source.ItemType == FilesystemItemType.Directory)
+            if (source is IStorageFolder)
             {
                 if (!string.IsNullOrWhiteSpace(source.Path) &&
                     Path.GetDirectoryName(destination).IsSubPathOf(source.Path)) // We check if user tried to copy anything above the source.ItemPath
@@ -216,7 +195,7 @@ await DialogDisplayHelper.ShowDialogAsync(
                     }
                 }
             }
-            else if (source.ItemType == FilesystemItemType.File)
+            else if (source is IStorageFile)
             {
                 var fsResult = (FilesystemResult)await Task.Run(() => NativeFileOperationsHelper.CopyFileFromApp(source.Path, destination, true));
 
@@ -291,9 +270,7 @@ await Windows.ApplicationModel.Core.CoreApplication.MainView.DispatcherQueue.Enq
                 return null; // Cannot undo overwrite operation
             }
 
-            var pathWithType = copiedItem.FromStorageItem(destination, source.ItemType);
-
-            return new StorageHistory(FileOperationType.Copy, source, pathWithType);
+            return new StorageHistory(FileOperationType.Copy, source, copiedItem);
         }
 
         public async Task<IStorageHistory> MoveAsync(IStorageItem source,
@@ -302,21 +279,6 @@ public async Task<IStorageHistory> MoveAsync(IStorageItem source,
                                                      IProgress<float> progress,
                                                      IProgress<FileSystemStatusCode> errorCode,
                                                      CancellationToken cancellationToken)
-        {
-            return await MoveAsync(source.FromStorageItem(),
-                                                    destination,
-                                                    collision,
-                                                    progress,
-                                                    errorCode,
-                                                    cancellationToken);
-        }
-
-        public async Task<IStorageHistory> MoveAsync(IStorageItemWithPath source,
-                                                     string destination,
-                                                     NameCollisionOption collision,
-                                                     IProgress<float> progress,
-                                                     IProgress<FileSystemStatusCode> errorCode,
-                                                     CancellationToken cancellationToken)
         {
             if (source.Path == destination)
             {
@@ -348,7 +310,7 @@ await DialogDisplayHelper.ShowDialogAsync(
             IStorageItem movedItem = null;
             //long itemSize = await FilesystemHelpers.GetItemSize(await source.ToStorageItem(associatedInstance));
 
-            if (source.ItemType == FilesystemItemType.Directory)
+            if (source is IStorageFolder)
             {
                 if (!string.IsNullOrWhiteSpace(source.Path) &&
                     Path.GetDirectoryName(destination).IsSubPathOf(source.Path)) // We check if user tried to move anything above the source.ItemPath
@@ -427,7 +389,7 @@ await DialogDisplayHelper.ShowDialogAsync(
                     errorCode?.Report(fsResult.ErrorCode);
                 }
             }
-            else if (source.ItemType == FilesystemItemType.File)
+            else if (source is IStorageFile)
             {
                 var fsResult = (FilesystemResult)await Task.Run(() => NativeFileOperationsHelper.MoveFileFromApp(source.Path, destination));
 
@@ -496,9 +458,7 @@ await Windows.ApplicationModel.Core.CoreApplication.MainView.DispatcherQueue.Enq
                 return null; // Cannot undo overwrite operation
             }
 
-            var pathWithType = movedItem.FromStorageItem(destination, source.ItemType);
-
-            return new StorageHistory(FileOperationType.Move, source, pathWithType);
+            return new StorageHistory(FileOperationType.Move, source, movedItem);
         }
 
         public async Task<IStorageHistory> DeleteAsync(IStorageItem source,
@@ -506,19 +466,6 @@ public async Task<IStorageHistory> DeleteAsync(IStorageItem source,
                                                        IProgress<FileSystemStatusCode> errorCode,
                                                        bool permanently,
                                                        CancellationToken cancellationToken)
-        {
-            return await DeleteAsync(source.FromStorageItem(),
-                                                      progress,
-                                                      errorCode,
-                                                      permanently,
-                                                      cancellationToken);
-        }
-
-        public async Task<IStorageHistory> DeleteAsync(IStorageItemWithPath source,
-                                                       IProgress<float> progress,
-                                                       IProgress<FileSystemStatusCode> errorCode,
-                                                       bool permanently,
-                                                       CancellationToken cancellationToken)
         {
             bool deleteFromRecycleBin = recycleBinHelpers.IsPathUnderRecycleBin(source.Path);
 
@@ -533,12 +480,12 @@ public async Task<IStorageHistory> DeleteAsync(IStorageItemWithPath source,
             }
             if (!fsResult)
             {
-                if (source.ItemType == FilesystemItemType.File)
+                if (source is IStorageFile)
                 {
                     fsResult = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(source.Path)
                         .OnSuccess((t) => t.DeleteAsync(permanently ? StorageDeleteOption.PermanentDelete : StorageDeleteOption.Default).AsTask());
                 }
-                else if (source.ItemType == FilesystemItemType.Directory)
+                else if (source is IStorageFolder)
                 {
                     fsResult = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(source.Path)
                         .OnSuccess((t) => t.DeleteAsync(permanently ? StorageDeleteOption.PermanentDelete : StorageDeleteOption.Default).AsTask());
@@ -631,15 +578,6 @@ public async Task<IStorageHistory> RenameAsync(IStorageItem source,
                                                        NameCollisionOption collision,
                                                        IProgress<FileSystemStatusCode> errorCode,
                                                        CancellationToken cancellationToken)
-        {
-            return await RenameAsync(StorageItemHelpers.FromStorageItem(source), newName, collision, errorCode, cancellationToken);
-        }
-
-        public async Task<IStorageHistory> RenameAsync(IStorageItemWithPath source,
-                                                       string newName,
-                                                       NameCollisionOption collision,
-                                                       IProgress<FileSystemStatusCode> errorCode,
-                                                       CancellationToken cancellationToken)
         {
             if (Path.GetFileName(source.Path) == newName && collision == NameCollisionOption.FailIfExists)
             {
@@ -668,7 +606,7 @@ public async Task<IStorageHistory> RenameAsync(IStorageItemWithPath source,
                 if (renamed)
                 {
                     errorCode?.Report(FileSystemStatusCode.Success);
-                    return new StorageHistory(FileOperationType.Rename, source, renamed.Result.FromStorageItem());
+                    return new StorageHistory(FileOperationType.Rename, source.CreateEnumerable(), renamed.Result.FromStorageItem());
                 }
                 else if (renamed == FileSystemStatusCode.Unauthorized)
                 {
@@ -747,7 +685,7 @@ public async Task<IStorageHistory> RenameAsync(IStorageItemWithPath source,
             return null;
         }
 
-        public async Task<IStorageHistory> RestoreFromTrashAsync(IStorageItemWithPath source,
+        public async Task<IStorageHistory> RestoreFromTrashAsync(IStorageItem source,
                                                                  string destination,
                                                                  IProgress<float> progress,
                                                                  IProgress<FileSystemStatusCode> errorCode,
@@ -760,7 +698,7 @@ public async Task<IStorageHistory> RestoreFromTrashAsync(IStorageItemWithPath so
 
             if (!fsResult)
             {
-                if (source.ItemType == FilesystemItemType.Directory)
+                if (source is IStorageFolder)
                 {
                     FilesystemResult<StorageFolder> sourceFolder = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(source.Path);
                     FilesystemResult<StorageFolder> destinationFolder = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(Path.GetDirectoryName(destination));
@@ -953,12 +891,7 @@ public async Task<IStorageHistory> CopyItemsAsync(IEnumerable<IStorageItemWithPa
             return null;
         }
 
-        public async Task<IStorageHistory> MoveItemsAsync(IEnumerable<IStorageItem> source, IEnumerable<string> destination, IEnumerable<FileNameConflictResolveOptionType> collisions, IProgress<float> progress, IProgress<FileSystemStatusCode> errorCode, CancellationToken cancellationToken)
-        {
-            return await MoveItemsAsync(source.Select((item) => item.FromStorageItem()).ToList(), destination, collisions, progress, errorCode, cancellationToken);
-        }
-
-        public async Task<IStorageHistory> MoveItemsAsync(IEnumerable<IStorageItemWithPath> source, IEnumerable<string> destination, IEnumerable<FileNameConflictResolveOptionType> collisions, IProgress<float> progress, IProgress<FileSystemStatusCode> errorCode, CancellationToken token)
+        public async Task<IStorageHistory> MoveItemsAsync(IEnumerable<IStorageItem> source, IEnumerable<string> destination, IEnumerable<FileNameConflictResolveOptionType> collisions, IProgress<float> progress, IProgress<FileSystemStatusCode> errorCode, CancellationToken token)
         {
             var rawStorageHistory = new List<IStorageHistory>();
 
@@ -993,12 +926,7 @@ public async Task<IStorageHistory> MoveItemsAsync(IEnumerable<IStorageItemWithPa
             return null;
         }
 
-        public async Task<IStorageHistory> DeleteItemsAsync(IEnumerable<IStorageItem> source, IProgress<float> progress, IProgress<FileSystemStatusCode> errorCode, bool permanently, CancellationToken cancellationToken)
-        {
-            return await DeleteItemsAsync(source.Select((item) => item.FromStorageItem()), progress, errorCode, permanently, cancellationToken);
-        }
-
-        public async Task<IStorageHistory> DeleteItemsAsync(IEnumerable<IStorageItemWithPath> source, IProgress<float> progress, IProgress<FileSystemStatusCode> errorCode, bool permanently, CancellationToken token)
+        public async Task<IStorageHistory> DeleteItemsAsync(IEnumerable<IStorageItem> source, IProgress<float> progress, IProgress<FileSystemStatusCode> errorCode, bool permanently, CancellationToken token)
         {
             bool originalPermanently = permanently;
             var rawStorageHistory = new List<IStorageHistory>();
diff --git a/Files/Filesystem/FilesystemOperations/IFilesystemOperations.cs b/Files/Filesystem/FilesystemOperations/IFilesystemOperations.cs
index c41a99c54bc9..9b0d3441ce97 100644
--- a/Files/Filesystem/FilesystemOperations/IFilesystemOperations.cs
+++ b/Files/Filesystem/FilesystemOperations/IFilesystemOperations.cs
@@ -30,7 +30,7 @@ public interface IFilesystemOperations : IDisposable
         /// <br/>
         /// Destination: null
         /// </returns>
-        Task<(IStorageHistory, IStorageItem)> CreateAsync(IStorageItemWithPath source, IProgress<FileSystemStatusCode> errorCode, CancellationToken cancellationToken);
+        Task<(IStorageHistory, IStorageItem)> CreateAsync(IStorageItem source, IProgress<FileSystemStatusCode> errorCode, CancellationToken cancellationToken);
 
         /// <summary>
         /// Copies <paramref name="source"/> to <paramref name="destination"/> fullPath
@@ -54,28 +54,6 @@ Task<IStorageHistory> CopyAsync(IStorageItem source,
                                         IProgress<FileSystemStatusCode> errorCode,
                                         CancellationToken cancellationToken);
 
-        /// <summary>
-        /// Copies <paramref name="source"/> to <paramref name="destination"/> fullPath
-        /// </summary>
-        /// <param name="source">The source item to be copied</param>
-        /// <param name="destination">The destination fullPath</param>
-        /// <param name="collision">The item naming collision</param>
-        /// <param name="progress">Progress of the operation</param>
-        /// <param name="errorCode">Status of the operation</param>
-        /// <param name="cancellationToken">Can be cancelled with <see cref="CancellationToken"/></param>
-        /// <returns><see cref="IStorageHistory"/> where:
-        /// <br/>
-        /// Source: The <paramref name="source"/> item fullPath (as <see cref="PathWithType"/>)
-        /// <br/>
-        /// Destination: The <paramref name="destination"/> item fullPath (as <see cref="PathWithType"/>) the <paramref name="source"/> was copied
-        /// </returns>
-        Task<IStorageHistory> CopyAsync(IStorageItemWithPath source,
-                                        string destination,
-                                        NameCollisionOption collision,
-                                        IProgress<float> progress,
-                                        IProgress<FileSystemStatusCode> errorCode,
-                                        CancellationToken cancellationToken);
-
         /// <summary>
         /// Copies <paramref name="source"/> to <paramref name="destination"/> fullPath
         /// </summary>
@@ -86,16 +64,6 @@ Task<IStorageHistory> CopyItemsAsync(IEnumerable<IStorageItem> source,
                                             IProgress<FileSystemStatusCode> errorCode, 
                                             CancellationToken cancellationToken);
 
-        /// <summary>
-        /// Copies <paramref name="source"/> to <paramref name="destination"/> fullPath
-        /// </summary>
-        Task<IStorageHistory> CopyItemsAsync(IEnumerable<IStorageItemWithPath> source, 
-                                            IEnumerable<string> destination,
-                                            IEnumerable<FileNameConflictResolveOptionType> collisions, 
-                                            IProgress<float> progress, 
-                                            IProgress<FileSystemStatusCode> errorCode, 
-                                            CancellationToken cancellationToken);
-
         /// <summary>
         /// Moves <paramref name="source"/> to <paramref name="destination"/> fullPath
         /// </summary>
@@ -118,28 +86,6 @@ Task<IStorageHistory> MoveAsync(IStorageItem source,
                                         IProgress<FileSystemStatusCode> errorCode,
                                         CancellationToken cancellationToken);
 
-        /// <summary>
-        /// Moves <paramref name="source"/> to <paramref name="destination"/> fullPath
-        /// </summary>
-        /// <param name="source">The source item to be moved</param>
-        /// <param name="destination">The destination fullPath</param>
-        /// <param name="collision">The item naming collision</param>
-        /// <param name="progress">Progress of the operation</param>
-        /// <param name="errorCode">Status of the operation</param>
-        /// <param name="cancellationToken">Can be cancelled with <see cref="CancellationToken"/></param>
-        /// <returns><see cref="IStorageHistory"/> where:
-        /// <br/>
-        /// Source: The source item fullPath (as <see cref="PathWithType"/>)
-        /// <br/>
-        /// Destination: The <paramref name="destination"/> item fullPath (as <see cref="PathWithType"/>) the <paramref name="source"/> was moved
-        /// </returns>
-        Task<IStorageHistory> MoveAsync(IStorageItemWithPath source,
-                                        string destination,
-                                        NameCollisionOption collision,
-                                        IProgress<float> progress,
-                                        IProgress<FileSystemStatusCode> errorCode,
-                                        CancellationToken cancellationToken);
-
         /// <summary>
         /// Moves <paramref name="source"/> to <paramref name="destination"/> fullPath
         /// </summary>
@@ -150,16 +96,6 @@ Task<IStorageHistory> MoveItemsAsync(IEnumerable<IStorageItem> source,
                                             IProgress<FileSystemStatusCode> errorCode,
                                             CancellationToken cancellationToken);
 
-        /// <summary>
-        /// Moves <paramref name="source"/> to <paramref name="destination"/> fullPath
-        /// </summary>
-        Task<IStorageHistory> MoveItemsAsync(IEnumerable<IStorageItemWithPath> source,
-                                            IEnumerable<string> destination,
-                                            IEnumerable<FileNameConflictResolveOptionType> collisions,
-                                            IProgress<float> progress,
-                                            IProgress<FileSystemStatusCode> errorCode,
-                                            CancellationToken cancellationToken);
-
         /// <summary>
         /// Deletes <paramref name="source"/>
         /// </summary>
@@ -184,31 +120,6 @@ Task<IStorageHistory> DeleteAsync(IStorageItem source,
                                           bool permanently,
                                           CancellationToken cancellationToken);
 
-        /// <summary>
-        /// Deletes <paramref name="source"/>
-        /// </summary>
-        /// <param name="source">The source to delete</param>
-        /// <param name="itemType">Type of the item</param>
-        /// <param name="progress">Progress of the operation</param>
-        /// <param name="errorCode">Status of the operation</param>
-        /// <param name="permanently">Determines whether <paramref name="source"/> is be deleted permanently</param>
-        /// <param name="cancellationToken">Can be cancelled with <see cref="CancellationToken"/></param>
-        /// <returns><see cref="IStorageHistory"/> where:
-        /// <br/>
-        /// Source: The deleted item fullPath (as <see cref="PathWithType"/>)
-        /// <br/>
-        /// Destination:
-        /// <br/>
-        /// Returns null if <paramref name="permanently"/> was true
-        /// <br/>
-        /// If <paramref name="permanently"/> was false, returns path to recycled item
-        /// </returns>
-        Task<IStorageHistory> DeleteAsync(IStorageItemWithPath source,
-                                          IProgress<float> progress,
-                                          IProgress<FileSystemStatusCode> errorCode,
-                                          bool permanently,
-                                          CancellationToken cancellationToken);
-
         /// <summary>
         /// Deletes provided <paramref name="source"/>
         /// </summary>
@@ -218,15 +129,6 @@ Task<IStorageHistory> DeleteItemsAsync(IEnumerable<IStorageItem> source,
                                             bool permanently, 
                                             CancellationToken cancellationToken);
 
-        /// <summary>
-        /// Deletes provided <paramref name="source"/>
-        /// </summary>
-        Task<IStorageHistory> DeleteItemsAsync(IEnumerable<IStorageItemWithPath> source, 
-                                            IProgress<float> progress, 
-                                            IProgress<FileSystemStatusCode> errorCode, 
-                                            bool permanently, 
-                                            CancellationToken cancellationToken);
-
         /// <summary>
         /// Renames <paramref name="source"/> with <paramref name="newName"/>
         /// </summary>
@@ -247,26 +149,6 @@ Task<IStorageHistory> RenameAsync(IStorageItem source,
                                           IProgress<FileSystemStatusCode> errorCode,
                                           CancellationToken cancellationToken);
 
-        /// <summary>
-        /// Renames <paramref name="source"/> fullPath with <paramref name="newName"/>
-        /// </summary>
-        /// <param name="source">The item to rename</param>
-        /// <param name="newName">Desired new name</param>
-        /// <param name="collision">Determines what to do if item already exists</param>
-        /// <param name="errorCode">Status of the operation</param>
-        /// <param name="cancellationToken">Can be cancelled with <see cref="CancellationToken"/></param>
-        /// <returns><see cref="IStorageHistory"/> where:
-        /// <br/>
-        /// Source: The original item fullPath (as <see cref="PathWithType"/>)
-        /// <br/>
-        /// Destination: The renamed item fullPath (as <see cref="PathWithType"/>)
-        /// </returns>
-        Task<IStorageHistory> RenameAsync(IStorageItemWithPath source,
-                                          string newName,
-                                          NameCollisionOption collision,
-                                          IProgress<FileSystemStatusCode> errorCode,
-                                          CancellationToken cancellationToken);
-
         /// <summary>
         /// Restores <paramref name="source"/> from the RecycleBin to <paramref name="destination"/> fullPath
         /// </summary>
@@ -281,7 +163,7 @@ Task<IStorageHistory> RenameAsync(IStorageItemWithPath source,
         /// <br/>
         /// Destination: The <paramref name="destination"/> item fullPath (as <see cref="PathWithType"/>) the <paramref name="source"/> has been restored
         /// </returns>
-        Task<IStorageHistory> RestoreFromTrashAsync(IStorageItemWithPath source,
+        Task<IStorageHistory> RestoreFromTrashAsync(IStorageItem source,
                                                     string destination,
                                                     IProgress<float> progress,
                                                     IProgress<FileSystemStatusCode> errorCode,
diff --git a/Files/Filesystem/StorageEnumerators/UniversalStorageEnumerator.cs b/Files/Filesystem/StorageEnumerators/UniversalStorageEnumerator.cs
index 04729aa8378e..9e3e817a618d 100644
--- a/Files/Filesystem/StorageEnumerators/UniversalStorageEnumerator.cs
+++ b/Files/Filesystem/StorageEnumerators/UniversalStorageEnumerator.cs
@@ -19,7 +19,7 @@ public static class UniversalStorageEnumerator
     {
         public static async Task<List<ListedItem>> ListEntries(
             StorageFolder rootFolder,
-            StorageFolderWithPath currentStorageFolder,
+            IStorageFolder currentStorageFolder,
             string returnformat,
             Type sourcePageType,
             CancellationToken cancellationToken,
@@ -138,7 +138,7 @@ ex is UnauthorizedAccessException
             return tempList;
         }
 
-        private static async Task<ListedItem> AddFolderAsync(StorageFolder folder, StorageFolderWithPath currentStorageFolder, string dateReturnFormat, CancellationToken cancellationToken)
+        private static async Task<ListedItem> AddFolderAsync(StorageFolder folder, IStorageFolder currentStorageFolder, string dateReturnFormat, CancellationToken cancellationToken)
         {
             var basicProperties = await folder.GetBasicPropertiesAsync();
             if (!cancellationToken.IsCancellationRequested)
@@ -166,7 +166,7 @@ private static async Task<ListedItem> AddFolderAsync(StorageFolder folder, Stora
 
         private static async Task<ListedItem> AddFileAsync(
             StorageFile file,
-            StorageFolderWithPath currentStorageFolder,
+            IStorageFolder currentStorageFolder,
             string dateReturnFormat,
             bool suppressThumbnailLoading,
             Type sourcePageType,
diff --git a/Files/Filesystem/StorageFileHelpers/FilesystemResult.cs b/Files/Filesystem/StorageFileHelpers/FilesystemResult.cs
index 7ff6a0151fac..d9cc2e0c434c 100644
--- a/Files/Filesystem/StorageFileHelpers/FilesystemResult.cs
+++ b/Files/Filesystem/StorageFileHelpers/FilesystemResult.cs
@@ -70,7 +70,7 @@ public static FileSystemStatusCode GetErrorCode(Exception ex, Type T = null)
             }
             else if (ex is ArgumentException) // Item was invalid
             {
-                return (T == typeof(StorageFolder) || T == typeof(StorageFolderWithPath)) ?
+                return (T == typeof(IStorageFolder) || T.GetInterface("IStorageFolder") is not null) ?
                     FileSystemStatusCode.NotAFolder : FileSystemStatusCode.NotAFile;
             }
             else if ((uint)ex.HResult == 0x800700B7)
diff --git a/Files/Filesystem/StorageFileHelpers/IStorageItemWithPath.cs b/Files/Filesystem/StorageFileHelpers/IStorageItemWithPath.cs
deleted file mode 100644
index 46e508639700..000000000000
--- a/Files/Filesystem/StorageFileHelpers/IStorageItemWithPath.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-using Windows.Storage;
-
-namespace Files.Filesystem
-{
-    public interface IStorageItemWithPath // TODO: Maybe use here : IStorageItem instead of declaring a variable,
-                                          // and keep the Path property for it to override IStorageItem.Path ?
-    {
-        public string Path { get; set; }
-        public IStorageItem Item { get; set; }
-        public FilesystemItemType ItemType { get; }
-    }
-}
\ No newline at end of file
diff --git a/Files/Filesystem/StorageFileHelpers/StorageFileExtensions.cs b/Files/Filesystem/StorageFileHelpers/StorageFileExtensions.cs
index b975ecffc706..59892dd17771 100644
--- a/Files/Filesystem/StorageFileHelpers/StorageFileExtensions.cs
+++ b/Files/Filesystem/StorageFileHelpers/StorageFileExtensions.cs
@@ -92,7 +92,7 @@ public static List<PathBoxItem> GetDirectoryPathComponents(string value)
             return pathBoxItems;
         }
 
-        public async static Task<StorageFolderWithPath> DangerousGetFolderWithPathFromPathAsync(string value, StorageFolderWithPath rootFolder = null, StorageFolderWithPath parentFolder = null)
+        public async static Task<IStorageFolder> DangerousGetFolderWithPathFromPathAsync(string value, IStorageFolder rootFolder = null, IStorageFolder parentFolder = null)
         {
             if (rootFolder != null)
             {
@@ -104,26 +104,22 @@ public async static Task<StorageFolderWithPath> DangerousGetFolderWithPathFromPa
                 }
                 else if (parentFolder != null && value.IsSubPathOf(parentFolder.Path))
                 {
-                    var folder = parentFolder.Folder;
+                    var folder = parentFolder;
                     var prevComponents = GetDirectoryPathComponents(parentFolder.Path);
-                    var path = parentFolder.Path;
                     foreach (var component in currComponents.ExceptBy(prevComponents, c => c.Path))
                     {
                         folder = await folder.GetFolderAsync(component.Title);
-                        path = Path.Combine(path, folder.Name);
                     }
-                    return new StorageFolderWithPath(folder, path);
+                    return folder;
                 }
                 else if (value.IsSubPathOf(rootFolder.Path))
                 {
-                    var folder = rootFolder.Folder;
-                    var path = rootFolder.Path;
+                    var folder = rootFolder;
                     foreach (var component in currComponents.Skip(1))
                     {
                         folder = await folder.GetFolderAsync(component.Title);
-                        path = Path.Combine(path, folder.Name);
                     }
-                    return new StorageFolderWithPath(folder, path);
+                    return folder;
                 }
             }
 
@@ -131,24 +127,24 @@ public async static Task<StorageFolderWithPath> DangerousGetFolderWithPathFromPa
             {
                 // Relative path
                 var fullPath = Path.GetFullPath(Path.Combine(parentFolder.Path, value));
-                return new StorageFolderWithPath(await StorageFolder.GetFolderFromPathAsync(fullPath));
+                return await StorageFolder.GetFolderFromPathAsync(fullPath);
             }
             else
             {
-                return new StorageFolderWithPath(await StorageFolder.GetFolderFromPathAsync(value));
+                return await StorageFolder.GetFolderFromPathAsync(value);
             }
         }
 
-        public async static Task<StorageFolder> DangerousGetFolderFromPathAsync(string value,
-                                                                                StorageFolderWithPath rootFolder = null,
-                                                                                StorageFolderWithPath parentFolder = null)
+        public async static Task<IStorageFolder> DangerousGetFolderFromPathAsync(string value,
+                                                                                IStorageFolder rootFolder = null,
+                                                                                IStorageFolder parentFolder = null)
         {
-            return (await DangerousGetFolderWithPathFromPathAsync(value, rootFolder, parentFolder)).Folder;
+            return await DangerousGetFolderWithPathFromPathAsync(value, rootFolder, parentFolder);
         }
 
-        public async static Task<StorageFileWithPath> DangerousGetFileWithPathFromPathAsync(string value,
-                                                                                            StorageFolderWithPath rootFolder = null,
-                                                                                            StorageFolderWithPath parentFolder = null)
+        public async static Task<IStorageFile> DangerousGetFileWithPathFromPathAsync(string value,
+                                                                                            IStorageFolder rootFolder = null,
+                                                                                            IStorageFolder parentFolder = null)
         {
             if (rootFolder != null)
             {
@@ -156,30 +152,24 @@ public async static Task<StorageFileWithPath> DangerousGetFileWithPathFromPathAs
 
                 if (parentFolder != null && value.IsSubPathOf(parentFolder.Path))
                 {
-                    var folder = parentFolder.Folder;
+                    var folder = parentFolder;
                     var prevComponents = GetDirectoryPathComponents(parentFolder.Path);
-                    var path = parentFolder.Path;
                     foreach (var component in currComponents.ExceptBy(prevComponents, c => c.Path).SkipLast(1))
                     {
                         folder = await folder.GetFolderAsync(component.Title);
-                        path = Path.Combine(path, folder.Name);
                     }
                     var file = await folder.GetFileAsync(currComponents.Last().Title);
-                    path = Path.Combine(path, file.Name);
-                    return new StorageFileWithPath(file, path);
+                    return file;
                 }
                 else if (value.IsSubPathOf(rootFolder.Path))
                 {
-                    var folder = rootFolder.Folder;
-                    var path = rootFolder.Path;
+                    var folder = rootFolder;
                     foreach (var component in currComponents.Skip(1).SkipLast(1))
                     {
                         folder = await folder.GetFolderAsync(component.Title);
-                        path = Path.Combine(path, folder.Name);
                     }
                     var file = await folder.GetFileAsync(currComponents.Last().Title);
-                    path = Path.Combine(path, file.Name);
-                    return new StorageFileWithPath(file, path);
+                    return file;
                 }
             }
 
@@ -187,40 +177,28 @@ public async static Task<StorageFileWithPath> DangerousGetFileWithPathFromPathAs
             {
                 // Relative path
                 var fullPath = Path.GetFullPath(Path.Combine(parentFolder.Path, value));
-                return new StorageFileWithPath(await StorageFile.GetFileFromPathAsync(fullPath));
+                return await StorageFile.GetFileFromPathAsync(fullPath);
             }
             else
             {
-                return new StorageFileWithPath(await StorageFile.GetFileFromPathAsync(value));
+                return await StorageFile.GetFileFromPathAsync(value);
             }
         }
 
-        public async static Task<StorageFile> DangerousGetFileFromPathAsync(string value,
-                                                                            StorageFolderWithPath rootFolder = null,
-                                                                            StorageFolderWithPath parentFolder = null)
+        public async static Task<IStorageFile> DangerousGetFileFromPathAsync(string value,
+                                                                            IStorageFolder rootFolder = null,
+                                                                            IStorageFolder parentFolder = null)
         {
-            return (await DangerousGetFileWithPathFromPathAsync(value, rootFolder, parentFolder)).File;
+            return await DangerousGetFileWithPathFromPathAsync(value, rootFolder, parentFolder);
         }
 
-        public async static Task<IList<StorageFolderWithPath>> GetFoldersWithPathAsync(this StorageFolderWithPath parentFolder, uint maxNumberOfItems = uint.MaxValue)
-        {
-            return (await parentFolder.Folder.GetFoldersAsync(CommonFolderQuery.DefaultQuery, 0, maxNumberOfItems))
-                .Select(x => new StorageFolderWithPath(x, Path.Combine(parentFolder.Path, x.Name))).ToList();
-        }
-
-        public async static Task<IList<StorageFileWithPath>> GetFilesWithPathAsync(this StorageFolderWithPath parentFolder, uint maxNumberOfItems = uint.MaxValue)
-        {
-            return (await parentFolder.Folder.GetFilesAsync(CommonFileQuery.DefaultQuery, 0, maxNumberOfItems))
-                .Select(x => new StorageFileWithPath(x, Path.Combine(parentFolder.Path, x.Name))).ToList();
-        }
-
-        public async static Task<IList<StorageFolderWithPath>> GetFoldersWithPathAsync(this StorageFolderWithPath parentFolder, string nameFilter, uint maxNumberOfItems = uint.MaxValue)
+        public async static Task<IList<StorageFolder>> GetFoldersWithPathAsync(this StorageFolder parentFolder, string nameFilter, uint maxNumberOfItems = uint.MaxValue)
         {
             var queryOptions = new QueryOptions();
             queryOptions.ApplicationSearchFilter = $"System.FileName:{nameFilter}*";
-            StorageFolderQueryResult queryResult = parentFolder.Folder.CreateFolderQueryWithOptions(queryOptions);
+            StorageFolderQueryResult queryResult = parentFolder.CreateFolderQueryWithOptions(queryOptions);
 
-            return (await queryResult.GetFoldersAsync(0, maxNumberOfItems)).Select(x => new StorageFolderWithPath(x, Path.Combine(parentFolder.Path, x.Name))).ToList();
+            return (await queryResult.GetFoldersAsync(0, maxNumberOfItems)).ToList();
         }
 
         public static string GetPathWithoutEnvironmentVariable(string path)
diff --git a/Files/Filesystem/StorageFileHelpers/StorageFileWithPath.cs b/Files/Filesystem/StorageFileHelpers/StorageFileWithPath.cs
deleted file mode 100644
index f5397dc1efb3..000000000000
--- a/Files/Filesystem/StorageFileHelpers/StorageFileWithPath.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using Windows.Storage;
-
-namespace Files.Filesystem
-{
-    public class StorageFileWithPath : IStorageItemWithPath
-    {
-        public StorageFile File
-        {
-            get
-            {
-                return (StorageFile)Item;
-            }
-            set
-            {
-                Item = value;
-            }
-        }
-
-        public string Path { get; set; }
-        public IStorageItem Item { get; set; }
-        public FilesystemItemType ItemType => FilesystemItemType.File;
-
-        public StorageFileWithPath(StorageFile file)
-        {
-            File = file;
-            Path = File.Path;
-        }
-
-        public StorageFileWithPath(StorageFile file, string path)
-        {
-            File = file;
-            Path = path;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Files/Filesystem/StorageFileHelpers/StorageFolderWithPath.cs b/Files/Filesystem/StorageFileHelpers/StorageFolderWithPath.cs
deleted file mode 100644
index 63174d5fe842..000000000000
--- a/Files/Filesystem/StorageFileHelpers/StorageFolderWithPath.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using Windows.Storage;
-
-namespace Files.Filesystem
-{
-    public class StorageFolderWithPath : IStorageItemWithPath
-    {
-        public StorageFolder Folder
-        {
-            get
-            {
-                return (StorageFolder)Item;
-            }
-            set
-            {
-                Item = value;
-            }
-        }
-
-        public string Path { get; set; }
-        public IStorageItem Item { get; set; }
-        public FilesystemItemType ItemType => FilesystemItemType.Directory;
-
-        public StorageFolderWithPath(StorageFolder folder)
-        {
-            Folder = folder;
-            Path = folder.Path;
-        }
-
-        public StorageFolderWithPath(StorageFolder folder, string path)
-        {
-            Folder = folder;
-            Path = path;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Files/Filesystem/StorageHistory/IStorageHistory.cs b/Files/Filesystem/StorageHistory/IStorageHistory.cs
index 5ccbb1bd8246..4aea5426d331 100644
--- a/Files/Filesystem/StorageHistory/IStorageHistory.cs
+++ b/Files/Filesystem/StorageHistory/IStorageHistory.cs
@@ -1,6 +1,7 @@
 using Files.Enums;
 using System;
 using System.Collections.Generic;
+using Windows.Storage;
 
 namespace Files.Filesystem.FilesystemHistory
 {
@@ -19,7 +20,7 @@ public interface IStorageHistory : IDisposable
         /// <br/>
         /// May contain more that one item
         /// </summary>
-        IEnumerable<IStorageItemWithPath> Source { get; }
+        IEnumerable<IStorageItem> Source { get; }
 
         /// <summary>
         /// Destination file/folder
@@ -29,15 +30,15 @@ public interface IStorageHistory : IDisposable
         /// <br/>
         /// May contain more that one item
         /// </summary>
-        IEnumerable<IStorageItemWithPath> Destination { get; }
+        IEnumerable<IStorageItem> Destination { get; }
 
         #region Modify
 
         void Modify(IStorageHistory newHistory);
 
-        void Modify(FileOperationType operationType, IEnumerable<IStorageItemWithPath> source, IEnumerable<IStorageItemWithPath> destination);
+        void Modify(FileOperationType operationType, IEnumerable<IStorageItem> source, IEnumerable<IStorageItem> destination);
 
-        void Modify(FileOperationType operationType, IStorageItemWithPath source, IStorageItemWithPath destination);
+        void Modify(FileOperationType operationType, IStorageItem source, IStorageItem destination);
 
         #endregion Modify
     }
diff --git a/Files/Filesystem/StorageHistory/StorageHistory.cs b/Files/Filesystem/StorageHistory/StorageHistory.cs
index 458687d2050c..1b99205ba183 100644
--- a/Files/Filesystem/StorageHistory/StorageHistory.cs
+++ b/Files/Filesystem/StorageHistory/StorageHistory.cs
@@ -1,6 +1,7 @@
 using Files.Enums;
 using Files.Extensions;
 using System.Collections.Generic;
+using Windows.Storage;
 
 namespace Files.Filesystem.FilesystemHistory
 {
@@ -10,22 +11,22 @@ public class StorageHistory : IStorageHistory
 
         public FileOperationType OperationType { get; private set; }
 
-        public IEnumerable<IStorageItemWithPath> Source { get; private set; }
+        public IEnumerable<IStorageItem> Source { get; private set; }
 
-        public IEnumerable<IStorageItemWithPath> Destination { get; private set; }
+        public IEnumerable<IStorageItem> Destination { get; private set; }
 
         #endregion Public Properties
 
         #region Constructor
 
-        public StorageHistory(FileOperationType operationType, IEnumerable<IStorageItemWithPath> source, IEnumerable<IStorageItemWithPath> destination)
+        public StorageHistory(FileOperationType operationType, IEnumerable<IStorageItem> source, IEnumerable<IStorageItem> destination)
         {
             OperationType = operationType;
             Source = source;
             Destination = destination;
         }
 
-        public StorageHistory(FileOperationType operationType, IStorageItemWithPath source, IStorageItemWithPath destination)
+        public StorageHistory(FileOperationType operationType, IStorageItem source, IStorageItem destination)
         {
             OperationType = operationType;
             Source = source.CreateEnumerable();
@@ -43,14 +44,14 @@ public void Modify(IStorageHistory newHistory)
             Destination = newHistory.Destination;
         }
 
-        public void Modify(FileOperationType operationType, IEnumerable<IStorageItemWithPath> source, IEnumerable<IStorageItemWithPath> destination)
+        public void Modify(FileOperationType operationType, IEnumerable<IStorageItem> source, IEnumerable<IStorageItem> destination)
         {
             OperationType = operationType;
             Source = source;
             Destination = destination;
         }
 
-        public void Modify(FileOperationType operationType, IStorageItemWithPath source, IStorageItemWithPath destination)
+        public void Modify(FileOperationType operationType, IStorageItem source, IStorageItem destination)
         {
             OperationType = operationType;
             Source = source.CreateEnumerable();
diff --git a/Files/Helpers/StorageItemHelpers.cs b/Files/Helpers/StorageItemHelpers.cs
index d263fac42a89..998d43de600b 100644
--- a/Files/Helpers/StorageItemHelpers.cs
+++ b/Files/Helpers/StorageItemHelpers.cs
@@ -108,27 +108,13 @@ public static async Task<long> GetFileSize(this IStorageFile file)
             return (long)properties.Size;
         }
 
-        public static async Task<FilesystemResult<IStorageItem>> ToStorageItemResult(this IStorageItemWithPath item, IShellPage associatedInstance = null)
+        public static async Task<FilesystemResult<IStorageItem>> ToStorageItemResult(this IStorageItem item, IShellPage associatedInstance = null)
         {
-            var returnedItem = new FilesystemResult<IStorageItem>(null, FileSystemStatusCode.Generic);
-            if (!string.IsNullOrEmpty(item.Path))
-            {
-                returnedItem = (item.ItemType == FilesystemItemType.File) ?
-                    ToType<IStorageItem, StorageFile>(associatedInstance != null ?
-                        await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(item.Path) :
-                        await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileFromPathAsync(item.Path))) :
-                    ToType<IStorageItem, StorageFolder>(associatedInstance != null ?
-                        await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(item.Path) :
-                        await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderFromPathAsync(item.Path)));
-            }
-            if (returnedItem.Result == null && item.Item != null)
-            {
-                returnedItem = new FilesystemResult<IStorageItem>(item.Item, FileSystemStatusCode.Success);
-            }
+            var returnedItem = new FilesystemResult<IStorageItem>(item, FileSystemStatusCode.Success);
             return returnedItem;
         }
 
-        public static IStorageItemWithPath FromPathAndType(string customPath, FilesystemItemType? itemType)
+        public static IStorageItem FromPathAndType(string customPath, FilesystemItemType? itemType)
         {
             return (itemType == FilesystemItemType.File) ?
                     (IStorageItemWithPath)new StorageFileWithPath(null, customPath) :
diff --git a/Files/Interacts/BaseLayoutCommandImplementationModel.cs b/Files/Interacts/BaseLayoutCommandImplementationModel.cs
index 092b656b2aae..f8c2708a933b 100644
--- a/Files/Interacts/BaseLayoutCommandImplementationModel.cs
+++ b/Files/Interacts/BaseLayoutCommandImplementationModel.cs
@@ -227,7 +227,7 @@ public virtual async void OpenFileLocation(RoutedEventArgs e)
 
             // Check if destination path exists
             string folderPath = Path.GetDirectoryName(item.TargetPath);
-            FilesystemResult<StorageFolderWithPath> destFolder = await associatedInstance.FilesystemViewModel.GetFolderWithPathFromPathAsync(folderPath);
+            FilesystemResult<IStorageFolder> destFolder = await associatedInstance.FilesystemViewModel.GetFolderWithPathFromPathAsync(folderPath);
 
             if (destFolder)
             {
diff --git a/Files/ViewModels/ItemViewModel.cs b/Files/ViewModels/ItemViewModel.cs
index f992b8983a15..1f2f7e121a33 100644
--- a/Files/ViewModels/ItemViewModel.cs
+++ b/Files/ViewModels/ItemViewModel.cs
@@ -86,8 +86,8 @@ public string WorkingDirectory
             get; private set;
         }
 
-        private StorageFolderWithPath currentStorageFolder;
-        private StorageFolderWithPath workingRoot;
+        private IStorageFolder currentStorageFolder;
+        private IStorageFolder workingRoot;
 
         public delegate void WorkingDirectoryModifiedEventHandler(object sender, WorkingDirectoryModifiedEventArgs e);
 
@@ -151,12 +151,12 @@ public async Task<FilesystemResult<StorageFile>> GetFileFromPathAsync(string val
             return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileFromPathAsync(value, workingRoot, currentStorageFolder));
         }
 
-        public async Task<FilesystemResult<StorageFolderWithPath>> GetFolderWithPathFromPathAsync(string value)
+        public async Task<FilesystemResult<IStorageFolder>> GetFolderWithPathFromPathAsync(string value)
         {
             return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(value, workingRoot, currentStorageFolder));
         }
 
-        public async Task<FilesystemResult<StorageFileWithPath>> GetFileWithPathFromPathAsync(string value)
+        public async Task<FilesystemResult<IStorageFile>> GetFileWithPathFromPathAsync(string value)
         {
             return await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(value, workingRoot, currentStorageFolder));
         }
@@ -1459,7 +1459,7 @@ await DialogDisplayHelper.ShowDialogAsync(
             }
         }
 
-        private async Task EnumFromStorageFolderAsync(string path, ListedItem currentFolder, StorageFolder rootFolder, StorageFolderWithPath currentStorageFolder, Type sourcePageType, CancellationToken cancellationToken)
+        private async Task EnumFromStorageFolderAsync(string path, ListedItem currentFolder, StorageFolder rootFolder, IStorageFolder currentStorageFolder, Type sourcePageType, CancellationToken cancellationToken)
         {
             Stopwatch stopwatch = new Stopwatch();
             stopwatch.Start();
diff --git a/Files/ViewModels/MainPageViewModel.cs b/Files/ViewModels/MainPageViewModel.cs
index 518fc5e2a3a5..6a15f99d8e41 100644
--- a/Files/ViewModels/MainPageViewModel.cs
+++ b/Files/ViewModels/MainPageViewModel.cs
@@ -336,13 +336,13 @@ public static async Task UpdateTabInfo(TabItem tabItem, object navigationArg)
                     fontIconSource.Glyph = "\xE8B7"; // Folder icon
                     tabLocationHeader = currentPath.TrimEnd(System.IO.Path.DirectorySeparatorChar, System.IO.Path.AltDirectorySeparatorChar).Split('\\', StringSplitOptions.RemoveEmptyEntries).Last();
 
-                    FilesystemResult<StorageFolderWithPath> rootItem = await FilesystemTasks.Wrap(() => DrivesManager.GetRootFromPathAsync(currentPath));
+                    FilesystemResult<IStorageFolder> rootItem = await FilesystemTasks.Wrap(() => DrivesManager.GetRootFromPathAsync(currentPath));
                     if (rootItem)
                     {
-                        StorageFolder currentFolder = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderFromPathAsync(currentPath, rootItem));
-                        if (currentFolder != null && !string.IsNullOrEmpty(currentFolder.DisplayName))
+                        IStorageFolder currentFolder = (await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderFromPathAsync(currentPath, rootItem.Result))).Result;
+                        if (currentFolder is StorageFolder folder && !string.IsNullOrEmpty(folder.DisplayName))
                         {
-                            tabLocationHeader = currentFolder.DisplayName;
+                            tabLocationHeader = folder.DisplayName;
                         }
                     }
                 }
diff --git a/Files/ViewModels/NavToolbarViewModel.cs b/Files/ViewModels/NavToolbarViewModel.cs
index 6f105336c005..99aa9ea63001 100644
--- a/Files/ViewModels/NavToolbarViewModel.cs
+++ b/Files/ViewModels/NavToolbarViewModel.cs
@@ -518,12 +518,12 @@ public void Dispose()
         public async Task SetPathBoxDropDownFlyoutAsync(MenuFlyout flyout, PathBoxItem pathItem, IShellPage shellPage)
         {
             var nextPathItemTitle = PathComponents[PathComponents.IndexOf(pathItem) + 1].Title;
-            IList<StorageFolderWithPath> childFolders = null;
+            IList<IStorageFolder> childFolders = null;
 
-            StorageFolderWithPath folder = await shellPage.FilesystemViewModel.GetFolderWithPathFromPathAsync(pathItem.Path);
-            if (folder != null)
+            IStorageFolder folder = (await shellPage.FilesystemViewModel.GetFolderWithPathFromPathAsync(pathItem.Path)).Result;
+            if (folder is StorageFolder storageFolder)
             {
-                childFolders = (await FilesystemTasks.Wrap(() => folder.GetFoldersWithPathAsync(string.Empty))).Result;
+                childFolders = (await FilesystemTasks.Wrap(() => storageFolder.GetFoldersWithPathAsync(string.Empty))).Result.Cast<IStorageFolder>().ToList();
             }
             flyout.Items?.Clear();
 
@@ -549,7 +549,7 @@ public async Task SetPathBoxDropDownFlyoutAsync(MenuFlyout flyout, PathBoxItem p
 
             foreach (var childFolder in childFolders)
             {
-                var isPathItemFocused = childFolder.Item.Name == nextPathItemTitle;
+                var isPathItemFocused = childFolder.Name == nextPathItemTitle;
 
                 var flyoutItem = new MenuFlyoutItem
                 {
@@ -558,7 +558,7 @@ public async Task SetPathBoxDropDownFlyoutAsync(MenuFlyout flyout, PathBoxItem p
                         Glyph = "\uED25",
                         FontWeight = isPathItemFocused ? boldFontWeight : normalFontWeight
                     },
-                    Text = childFolder.Item.Name,
+                    Text = childFolder.Name,
                     FontSize = 12,
                     FontWeight = isPathItemFocused ? boldFontWeight : normalFontWeight
                 };
@@ -607,7 +607,7 @@ public async Task CheckPathInput(string currentInput, string currentSelectedPath
 
                     var item = await FilesystemTasks.Wrap(() => DrivesManager.GetRootFromPathAsync(currentInput));
 
-                    var resFolder = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(currentInput, item));
+                    var resFolder = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFolderWithPathFromPathAsync(currentInput, item.Result));
                     if (resFolder || FolderHelpers.CheckFolderAccessWithWin32(currentInput))
                     {
                         var pathToNavigate = resFolder.Result?.Path ?? currentInput;
@@ -615,7 +615,7 @@ public async Task CheckPathInput(string currentInput, string currentSelectedPath
                     }
                     else // Not a folder or inaccessible
                     {
-                        var resFile = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(currentInput, item));
+                        var resFile = await FilesystemTasks.Wrap(() => StorageFileExtensions.DangerousGetFileWithPathFromPathAsync(currentInput, item.Result));
                         if (resFile)
                         {
                             var pathToInvoke = resFile.Result.Path;
@@ -681,27 +681,31 @@ public async void SetAddressBarSuggestions(AutoSuggestBox sender, IShellPage she
                     var expandedPath = StorageFileExtensions.GetPathWithoutEnvironmentVariable(sender.Text);
                     var folderPath = Path.GetDirectoryName(expandedPath) ?? expandedPath;
                     var folder = await shellpage.FilesystemViewModel.GetFolderWithPathFromPathAsync(folderPath);
-                    var currPath = await folder.Result.GetFoldersWithPathAsync(Path.GetFileName(expandedPath), (uint)maxSuggestions);
+                    if (folder.Result is not StorageFolder storageFolder)
+                    {
+                        return;
+                    }
+                    var currPath = await storageFolder.GetFoldersWithPathAsync(Path.GetFileName(expandedPath), (uint)maxSuggestions);
                     if (currPath.Count() >= maxSuggestions)
                     {
                         suggestions = currPath.Select(x => new ListedItem(null)
                         {
                             ItemPath = x.Path,
-                            ItemName = x.Folder.DisplayName
+                            ItemName = x.DisplayName
                         }).ToList();
                     }
                     else if (currPath.Any())
                     {
-                        var subPath = await currPath.First().GetFoldersWithPathAsync((uint)(maxSuggestions - currPath.Count()));
+                        var subPath = await currPath.First().GetFoldersWithPathAsync("", (uint)(maxSuggestions - currPath.Count()));
                         suggestions = currPath.Select(x => new ListedItem(null)
                         {
                             ItemPath = x.Path,
-                            ItemName = x.Folder.DisplayName
+                            ItemName = x.DisplayName
                         }).Concat(
                             subPath.Select(x => new ListedItem(null)
                             {
                                 ItemPath = x.Path,
-                                ItemName = Path.Combine(currPath.First().Folder.DisplayName, x.Folder.DisplayName)
+                                ItemName = Path.Combine(currPath.First().DisplayName, x.DisplayName)
                             })).ToList();
                     }
                     else