Обнновлено до .net10

YandexMusic.API/API/YAlbumAPI.cs

@@ -5,34 +5,24 @@ using YandexMusic.API.Requests.Album;
 
 namespace YandexMusic.API;
 
-/// <summary>
-/// API для взаимодействия с альбомами
-/// </summary>
+/// <summary>API для работы с альбомами.</summary>
 public class YAlbumAPI : YCommonAPI
 {
-    public YAlbumAPI(YandexMusicApi yandex) : base(yandex)
-    {
-    }
+    /// <summary>Инициализирует новый экземпляр API альбомов.</summary>
+    /// <param name="yandex">Экземпляр основного API.</param>
+    public YAlbumAPI(YandexMusicApi yandex) : base(yandex) { }
 
     /// <summary>Получает альбом по идентификатору.</summary>
-    /// <param name="storage">Хранилище авторизации.</param>
+    /// <param name="storage">Хранилище данных авторизации.</param>
     /// <param name="albumId">Идентификатор альбома.</param>
-    /// <returns></returns>
+    /// <returns>Ответ API с моделью альбома.</returns>
     public Task<YResponse<YAlbum>> GetAsync(AuthStorage storage, string albumId)
-    {
-        return new YGetAlbumBuilder(api, storage)
-            .Build(albumId)
-            .GetResponseAsync();
-    }
+        => new YGetAlbumBuilder(api, storage).Build(albumId).GetResponseAsync();
 
-    /// <summary>Получение альбомов по списку идентификаторов.</summary>
-    /// <param name="storage">Хранилище авторизации.</param>
-    /// <param name="albumIds">Идентификаторы альбомов.</param> 
-    /// <returns></returns>
+    /// <summary>Получает несколько альбомов по списку идентификаторов.</summary>
+    /// <param name="storage">Хранилище данных авторизации.</param>
+    /// <param name="albumIds">Список идентификаторов альбомов.</param>
+    /// <returns>Ответ API со списком альбомов.</returns>
     public Task<YResponse<List<YAlbum>>> GetAsync(AuthStorage storage, IEnumerable<string> albumIds)
-    {
-        return new YGetAlbumsBuilder(api, storage)
-            .Build(albumIds)
-            .GetResponseAsync();
-    }
+        => new YGetAlbumsBuilder(api, storage).Build(albumIds).GetResponseAsync();
 }

YandexMusic.API/API/YCommonAPI.cs

@@ -1,14 +1,12 @@
 namespace YandexMusic.API;
 
-/// <summary>
-/// Родительский класс для ветки API
-/// </summary>
-public class YCommonAPI
+/// <summary>Родительский класс для всех веток API.</summary>
+public abstract class YCommonAPI
 {
-    protected YandexMusicApi api;
+    /// <summary>Основной экземпляр API.</summary>
+    protected readonly YandexMusicApi api;
 
-    public YCommonAPI(YandexMusicApi yandex)
-    {
-        api = yandex;
-    }
+    /// <summary>Инициализирует новый экземпляр.</summary>
+    /// <param name="yandex">Экземпляр основного API.</param>
+    protected YCommonAPI(YandexMusicApi yandex) => api = yandex;
 }

YandexMusic.API/API/YLabelAPI.cs

@@ -0,0 +1,39 @@
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Models.Label;
+using YandexMusic.API.Requests.Label;
+
+namespace YandexMusic.API;
+
+public partial class YLabelAPI : YCommonAPI
+{
+    public YLabelAPI(YandexMusicApi yandex) : base(yandex)
+    {
+    }
+
+    /// <summary>
+    /// Постраничное получение альбомов лейбла
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="label">Лейбл</param>
+    /// <param name="page">Страница</param>
+    public Task<YResponse<YLabelAlbums>> GetAlbumsByLabelAsync(AuthStorage storage, YLabel label, int page)
+    {
+        return new YGetLabelAlbumsBuilder(api, storage)
+            .Build((label, page))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Постраничное получение артистов лейбла
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="label">Лейбл</param>
+    /// <param name="page">Страница</param>
+    public Task<YResponse<YLabelArtists>> GetArtistsByLabelAsync(AuthStorage storage, YLabel label, int page)
+    {
+        return new YGetLabelArtistsBuilder(api, storage)
+            .Build((label, page))
+            .GetResponseAsync();
+    }
+}

YandexMusic.API/API/YLabelAPIAsync.cs

@@ -1,40 +0,0 @@
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Models.Label;
-using YandexMusic.API.Requests.Label;
-
-namespace YandexMusic.API
-{
-    public partial class YLabelAPI : YCommonAPI
-    {
-        public YLabelAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        /// <summary>
-        /// Постраничное получение альбомов лейбла
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="label">Лейбл</param>
-        /// <param name="page">Страница</param>
-        public Task<YResponse<YLabelAlbums>> GetAlbumsByLabelAsync(AuthStorage storage, YLabel label, int page)
-        {
-            return new YGetLabelAlbumsBuilder(api, storage)
-                .Build((label, page))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Постраничное получение артистов лейбла
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="label">Лейбл</param>
-        /// <param name="page">Страница</param>
-        public Task<YResponse<YLabelArtists>> GetArtistsByLabelAsync(AuthStorage storage, YLabel label, int page)
-        {
-            return new YGetLabelArtistsBuilder(api, storage)
-                .Build((label, page))
-                .GetResponseAsync();
-        }
-    }
-}

YandexMusic.API/API/YLandingAPI.cs

@@ -0,0 +1,43 @@
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Models.Feed;
+using YandexMusic.API.Models.Landing;
+using YandexMusic.API.Requests.Feed;
+using YandexMusic.API.Requests.Landing;
+
+namespace YandexMusic.API;
+
+/// <summary>API для взаимодействия с главной страницей (лендингом).</summary>
+public class YLandingAPI : YCommonAPI
+{
+    /// <summary>Инициализирует новый экземпляр API лендинга.</summary>
+    /// <param name="yandex">Экземпляр основного API.</param>
+    public YLandingAPI(YandexMusicApi yandex) : base(yandex) { }
+
+    /// <summary>Получает персональные блоки лендинга.</summary>
+    /// <param name="storage">Хранилище авторизации.</param>
+    /// <param name="blocks">Типы запрашиваемых блоков.</param>
+    /// <returns>Ответ API с лендингом.</returns>
+    /// <exception cref="ArgumentNullException">Если массив blocks равен null.</exception>
+    public Task<YResponse<YLanding>> GetAsync(AuthStorage storage, params YLandingBlockType[] blocks)
+    {
+        if (blocks == null)
+            throw new ArgumentNullException(nameof(blocks), "Массив блоков не может быть null");
+
+        return new YGetLandingBuilder(api, storage)
+            .Build(blocks)
+            .GetResponseAsync();
+    }
+
+    /// <summary>Получает ленту событий (фид).</summary>
+    /// <param name="storage">Хранилище авторизации.</param>
+    /// <returns>Ответ API с лентой.</returns>
+    public Task<YResponse<YFeed>> GetFeedAsync(AuthStorage storage)
+        => new YGetFeedBuilder(api, storage).Build(null!).GetResponseAsync();
+
+    /// <summary>Получает лендинг детского раздела.</summary>
+    /// <param name="storage">Хранилище авторизации.</param>
+    /// <returns>Ответ API с детским лендингом.</returns>
+    public Task<YResponse<YChildrenLanding>> GetChildrenLandingAsync(AuthStorage storage)
+        => new YGetChildrenLandingBuilder(api, storage).Build(null!).GetResponseAsync();
+}

YandexMusic.API/API/YLandingAPIAsync.cs

@@ -1,63 +0,0 @@
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Models.Feed;
-using YandexMusic.API.Models.Landing;
-using YandexMusic.API.Requests.Feed;
-using YandexMusic.API.Requests.Landing;
-
-namespace YandexMusic.API
-{
-    /// <summary>
-    /// API для взаимодействия с главной страницей
-    /// </summary>
-    public partial class YLandingAPI : YCommonAPI
-    {
-
-
-        public YLandingAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        /// <summary>
-        /// Получение персональных списков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="blocks">Типы запрашиваемых блоков</param>
-        /// <returns></returns>
-        public Task<YResponse<YLanding>> GetAsync(AuthStorage storage, params YLandingBlockType[] blocks)
-        {
-            if (blocks == null)
-                return null;
-
-            return new YGetLandingBuilder(api, storage)
-                .Build(blocks)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение ленты
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YFeed>> GetFeedAsync(AuthStorage storage)
-        {
-            return new YGetFeedBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение лендинга детского раздела
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YChildrenLanding>> GetChildrenLandingAsync(AuthStorage storage)
-        {
-            return new YGetChildrenLandingBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-        }
-
-
-    }
-}

YandexMusic.API/API/YLibraryAPI.cs

@@ -0,0 +1,253 @@
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Album;
+using YandexMusic.API.Models.Artist;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Models.Landing.Entity.Entities.Context;
+using YandexMusic.API.Models.Library;
+using YandexMusic.API.Models.Playlist;
+using YandexMusic.API.Models.Track;
+using YandexMusic.API.Requests.Library;
+
+namespace YandexMusic.API;
+
+/// <summary>
+/// API для взаимодействия с библиотекой
+/// </summary>
+public partial class YLibraryAPI : YCommonAPI
+{
+    /// <summary>
+    /// Получение секции библиотеки
+    /// </summary>
+    /// <typeparam name="T">Тип объекта библиотеки</typeparam>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="section">Секция</param>
+    /// <param name="type">Тип</param>
+    /// <returns>Список объектов из секции</returns>
+    private Task<YResponse<T>> GetLibrarySection<T>(AuthStorage storage, YLibrarySection section, YLibrarySectionType type = YLibrarySectionType.Likes)
+    {
+        return new YGetLibrarySectionBuilder<T>(api, storage)
+            .Build((section, type))
+            .GetResponseAsync();
+    }
+
+
+
+    public YLibraryAPI(YandexMusicApi yandex) : base(yandex)
+    {
+    }
+
+    #region Лайки
+
+    /// <summary>
+    /// Получение лайкнутых треков
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YResponse<YLibraryTracks>> GetLikedTracksAsync(AuthStorage storage)
+    {
+        return GetLibrarySection<YLibraryTracks>(storage, YLibrarySection.Tracks);
+    }
+
+    /// <summary>
+    /// Получение лайкнутых альбомов
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YLibraryAlbum>>> GetLikedAlbumsAsync(AuthStorage storage)
+    {
+        return GetLibrarySection<List<YLibraryAlbum>>(storage, YLibrarySection.Albums);
+    }
+
+    /// <summary>
+    /// Получение лайкнутых исполнителей
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YArtist>>> GetLikedArtistsAsync(AuthStorage storage)
+    {
+        return GetLibrarySection<List<YArtist>>(storage, YLibrarySection.Artists);
+    }
+
+    /// <summary>
+    /// Получение лайкнутых плейлистов
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YLibraryPlaylists>>> GetLikedPlaylistsAsync(AuthStorage storage)
+    {
+        return GetLibrarySection<List<YLibraryPlaylists>>(storage, YLibrarySection.Playlists);
+    }
+
+    #endregion Лайки
+
+    #region Дизлайки
+
+    /// <summary>
+    /// Получение дизлайкнутых треков
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YResponse<YLibraryTracks>> GetDislikedTracksAsync(AuthStorage storage)
+    {
+        return GetLibrarySection<YLibraryTracks>(storage, YLibrarySection.Tracks, YLibrarySectionType.Dislikes);
+    }
+
+    /// <summary>
+    /// Получение дизлайкнутых исполнителей
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YArtist>>> GetDislikedArtistsAsync(AuthStorage storage)
+    {
+        return GetLibrarySection<List<YArtist>>(storage, YLibrarySection.Artists, YLibrarySectionType.Dislikes);
+    }
+
+    #endregion Дизлайки
+
+    #region Добавление в списки лайков/дизлайков
+
+    /// <summary>
+    /// Добавить трек в список лайкнутых
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <returns></returns>
+    public Task<YResponse<YPlaylist>> AddTrackLikeAsync(AuthStorage storage, YTrack track)
+    {
+        return new YLibraryAddBuilder<YPlaylist>(api, storage)
+            .Build((track.GetKey().ToString(), YLibrarySection.Tracks, YLibrarySectionType.Likes))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Удалить трек из списка лайкнутых
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <returns></returns>
+    public Task<YResponse<YRevision>> RemoveTrackLikeAsync(AuthStorage storage, YTrack track)
+    {
+        return new YLibraryRemoveBuilder<YRevision>(api, storage)
+            .Build((track.GetKey().ToString(), YLibrarySection.Tracks, YLibrarySectionType.Likes))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Добавить трек в список дизлайкнутых
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <returns></returns>
+    public Task<YResponse<YRevision>> AddTrackDislikeAsync(AuthStorage storage, YTrack track)
+    {
+        return new YLibraryAddBuilder<YRevision>(api, storage)
+            .Build((track.GetKey().ToString(), YLibrarySection.Tracks, YLibrarySectionType.Dislikes))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Удалить трек из списка дизлайкнутых
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <returns></returns>
+    public Task<YResponse<YRevision>> RemoveTrackDislikeAsync(AuthStorage storage, YTrack track)
+    {
+        return new YLibraryRemoveBuilder<YRevision>(api, storage)
+            .Build((track.GetKey().ToString(), YLibrarySection.Tracks, YLibrarySectionType.Dislikes))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Добавить альбом в список лайкнутых
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="album">Альбом</param>
+    /// <returns></returns>
+    public Task<YResponse<string>> AddAlbumLikeAsync(AuthStorage storage, YAlbum album)
+    {
+        return new YLibraryAddBuilder<string>(api, storage)
+            .Build((album.Id, YLibrarySection.Albums, YLibrarySectionType.Likes))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Удалить альбом из списка лайкнутых
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="album">Альбом</param>
+    /// <returns></returns>
+    public Task<YResponse<string>> RemoveAlbumLikeAsync(AuthStorage storage, YAlbum album)
+    {
+        return new YLibraryRemoveBuilder<string>(api, storage)
+            .Build((album.Id, YLibrarySection.Albums, YLibrarySectionType.Likes))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Добавить исполнителя в список лайкнутых
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="artist">Исполнитель</param>
+    /// <returns></returns>
+    public Task<YResponse<string>> AddArtistLikeAsync(AuthStorage storage, YArtist artist)
+    {
+        return new YLibraryAddBuilder<string>(api, storage)
+            .Build((artist.Id, YLibrarySection.Artists, YLibrarySectionType.Likes))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Удалить исполнителя из списка лайкнутых
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="artist">Исполнитель</param>
+    /// <returns></returns>
+    public Task<YResponse<string>> RemoveArtistLikeAsync(AuthStorage storage, YArtist artist)
+    {
+        return new YLibraryRemoveBuilder<string>(api, storage)
+            .Build((artist.Id, YLibrarySection.Artists, YLibrarySectionType.Likes))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Добавить плейлист в список лайкнутых
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="playlist">Плейлист</param>
+    /// <returns></returns>
+    public Task<YResponse<string>> AddPlaylistLikeAsync(AuthStorage storage, YPlaylist playlist)
+    {
+        return new YLibraryAddBuilder<string>(api, storage)
+            .Build((playlist.GetKey().ToString(), YLibrarySection.Playlists, YLibrarySectionType.Likes))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Удалить плейлист из списка лайкнутых
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="playlist">Плейлист</param>
+    /// <returns></returns>
+    public Task<YResponse<string>> RemovePlaylistLikeAsync(AuthStorage storage, YPlaylist playlist)
+    {
+        return new YLibraryRemoveBuilder<string>(api, storage)
+            .Build((playlist.GetKey().ToString(), YLibrarySection.Playlists, YLibrarySectionType.Likes))
+            .GetResponseAsync();
+    }
+
+    #endregion Добавление/удаление в списки лайков/дизлайков
+
+    #region Получение списка "Вы недавно слушали"
+
+    public Task<YResponse<YRecentlyListenedContext>> GetRecentlyListenedAsync(AuthStorage storage, IEnumerable<YPlayContextType> contextTypes, int trackCount, int contextCount)
+    {
+        return new YGetLibraryRecentlyListenedBuilder(api, storage)
+            .Build((contextTypes, trackCount, contextCount))
+            .GetResponseAsync();
+    }
+
+    #endregion Получение списка "Вы недавно слушали"
+
+
+}

YandexMusic.API/API/YLibraryAPIAsync.cs

@@ -1,258 +0,0 @@
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Album;
-using YandexMusic.API.Models.Artist;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Models.Landing.Entity.Entities.Context;
-using YandexMusic.API.Models.Library;
-using YandexMusic.API.Models.Playlist;
-using YandexMusic.API.Models.Track;
-using YandexMusic.API.Requests.Library;
-
-namespace YandexMusic.API
-{
-    /// <summary>
-    /// API для взаимодействия с библиотекой
-    /// </summary>
-    public partial class YLibraryAPI : YCommonAPI
-    {
-        #region Вспомогательные функции
-
-        /// <summary>
-        /// Получение секции библиотеки
-        /// </summary>
-        /// <typeparam name="T">Тип объекта библиотеки</typeparam>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="section">Секция</param>
-        /// <param name="type">Тип</param>
-        /// <returns>Список объектов из секции</returns>
-        private Task<YResponse<T>> GetLibrarySection<T>(AuthStorage storage, YLibrarySection section, YLibrarySectionType type = YLibrarySectionType.Likes)
-        {
-            return new YGetLibrarySectionBuilder<T>(api, storage)
-                .Build((section, type))
-                .GetResponseAsync();
-        }
-
-        #endregion Вспомогательные функции
-
-
-
-        public YLibraryAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        #region Лайки
-
-        /// <summary>
-        /// Получение лайкнутых треков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YLibraryTracks>> GetLikedTracksAsync(AuthStorage storage)
-        {
-            return GetLibrarySection<YLibraryTracks>(storage, YLibrarySection.Tracks);
-        }
-
-        /// <summary>
-        /// Получение лайкнутых альбомов
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YLibraryAlbum>>> GetLikedAlbumsAsync(AuthStorage storage)
-        {
-            return GetLibrarySection<List<YLibraryAlbum>>(storage, YLibrarySection.Albums);
-        }
-
-        /// <summary>
-        /// Получение лайкнутых исполнителей
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YArtist>>> GetLikedArtistsAsync(AuthStorage storage)
-        {
-            return GetLibrarySection<List<YArtist>>(storage, YLibrarySection.Artists);
-        }
-
-        /// <summary>
-        /// Получение лайкнутых плейлистов
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YLibraryPlaylists>>> GetLikedPlaylistsAsync(AuthStorage storage)
-        {
-            return GetLibrarySection<List<YLibraryPlaylists>>(storage, YLibrarySection.Playlists);
-        }
-
-        #endregion Лайки
-
-        #region Дизлайки
-
-        /// <summary>
-        /// Получение дизлайкнутых треков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YLibraryTracks>> GetDislikedTracksAsync(AuthStorage storage)
-        {
-            return GetLibrarySection<YLibraryTracks>(storage, YLibrarySection.Tracks, YLibrarySectionType.Dislikes);
-        }
-
-        /// <summary>
-        /// Получение дизлайкнутых исполнителей
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YArtist>>> GetDislikedArtistsAsync(AuthStorage storage)
-        {
-            return GetLibrarySection<List<YArtist>>(storage, YLibrarySection.Artists, YLibrarySectionType.Dislikes);
-        }
-
-        #endregion Дизлайки
-
-        #region Добавление в списки лайков/дизлайков
-
-        /// <summary>
-        /// Добавить трек в список лайкнутых
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> AddTrackLikeAsync(AuthStorage storage, YTrack track)
-        {
-            return new YLibraryAddBuilder<YPlaylist>(api, storage)
-                .Build((track.GetKey().ToString(), YLibrarySection.Tracks, YLibrarySectionType.Likes))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Удалить трек из списка лайкнутых
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <returns></returns>
-        public Task<YResponse<YRevision>> RemoveTrackLikeAsync(AuthStorage storage, YTrack track)
-        {
-            return new YLibraryRemoveBuilder<YRevision>(api, storage)
-                .Build((track.GetKey().ToString(), YLibrarySection.Tracks, YLibrarySectionType.Likes))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Добавить трек в список дизлайкнутых
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <returns></returns>
-        public Task<YResponse<YRevision>> AddTrackDislikeAsync(AuthStorage storage, YTrack track)
-        {
-            return new YLibraryAddBuilder<YRevision>(api, storage)
-                .Build((track.GetKey().ToString(), YLibrarySection.Tracks, YLibrarySectionType.Dislikes))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Удалить трек из списка дизлайкнутых
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <returns></returns>
-        public Task<YResponse<YRevision>> RemoveTrackDislikeAsync(AuthStorage storage, YTrack track)
-        {
-            return new YLibraryRemoveBuilder<YRevision>(api, storage)
-                .Build((track.GetKey().ToString(), YLibrarySection.Tracks, YLibrarySectionType.Dislikes))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Добавить альбом в список лайкнутых
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="album">Альбом</param>
-        /// <returns></returns>
-        public Task<YResponse<string>> AddAlbumLikeAsync(AuthStorage storage, YAlbum album)
-        {
-            return new YLibraryAddBuilder<string>(api, storage)
-                .Build((album.Id, YLibrarySection.Albums, YLibrarySectionType.Likes))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Удалить альбом из списка лайкнутых
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="album">Альбом</param>
-        /// <returns></returns>
-        public Task<YResponse<string>> RemoveAlbumLikeAsync(AuthStorage storage, YAlbum album)
-        {
-            return new YLibraryRemoveBuilder<string>(api, storage)
-                .Build((album.Id, YLibrarySection.Albums, YLibrarySectionType.Likes))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Добавить исполнителя в список лайкнутых
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="artist">Исполнитель</param>
-        /// <returns></returns>
-        public Task<YResponse<string>> AddArtistLikeAsync(AuthStorage storage, YArtist artist)
-        {
-            return new YLibraryAddBuilder<string>(api, storage)
-                .Build((artist.Id, YLibrarySection.Artists, YLibrarySectionType.Likes))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Удалить исполнителя из списка лайкнутых
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="artist">Исполнитель</param>
-        /// <returns></returns>
-        public Task<YResponse<string>> RemoveArtistLikeAsync(AuthStorage storage, YArtist artist)
-        {
-            return new YLibraryRemoveBuilder<string>(api, storage)
-                .Build((artist.Id, YLibrarySection.Artists, YLibrarySectionType.Likes))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Добавить плейлист в список лайкнутых
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="playlist">Плейлист</param>
-        /// <returns></returns>
-        public Task<YResponse<string>> AddPlaylistLikeAsync(AuthStorage storage, YPlaylist playlist)
-        {
-            return new YLibraryAddBuilder<string>(api, storage)
-                .Build((playlist.GetKey().ToString(), YLibrarySection.Playlists, YLibrarySectionType.Likes))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Удалить плейлист из списка лайкнутых
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="playlist">Плейлист</param>
-        /// <returns></returns>
-        public Task<YResponse<string>> RemovePlaylistLikeAsync(AuthStorage storage, YPlaylist playlist)
-        {
-            return new YLibraryRemoveBuilder<string>(api, storage)
-                .Build((playlist.GetKey().ToString(), YLibrarySection.Playlists, YLibrarySectionType.Likes))
-                .GetResponseAsync();
-        }
-
-        #endregion Добавление/удаление в списки лайков/дизлайков
-
-        #region Получение списка "Вы недавно слушали"
-
-        public Task<YResponse<YRecentlyListenedContext>> GetRecentlyListenedAsync(AuthStorage storage, IEnumerable<YPlayContextType> contextTypes, int trackCount, int contextCount)
-        {
-            return new YGetLibraryRecentlyListenedBuilder(api, storage)
-                .Build((contextTypes, trackCount, contextCount))
-                .GetResponseAsync();
-        }
-
-        #endregion Получение списка "Вы недавно слушали"
-
-
-    }
-}

YandexMusic.API/API/YPinsAPI.cs

@@ -0,0 +1,20 @@
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Models.Pins;
+using YandexMusic.API.Requests.Pins;
+
+namespace YandexMusic.API;
+
+/// <summary>API для взаимодействия с закреплёнными объектами (пинами).</summary>
+public class YPinsAPI : YCommonAPI
+{
+    /// <summary>Инициализирует новый экземпляр API пинов.</summary>
+    /// <param name="yandex">Экземпляр основного API.</param>
+    public YPinsAPI(YandexMusicApi yandex) : base(yandex) { }
+
+    /// <summary>Получает список закреплённых объектов.</summary>
+    /// <param name="storage">Хранилище авторизации.</param>
+    /// <returns>Ответ API со списком пинов.</returns>
+    public Task<YResponse<YPins>> GetAsync(AuthStorage storage)
+        => new YGetPinsBuilder(api, storage).Build(null!).GetResponseAsync();
+}

YandexMusic.API/API/YPinsAPIAsync.cs

@@ -1,33 +0,0 @@
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Models.Pins;
-using YandexMusic.API.Requests.Pins;
-
-namespace YandexMusic.API
-{
-    /// <summary>
-    /// API для взаимодействия с прикреплёнными объектами
-    /// </summary>
-    public partial class YPinsAPI : YCommonAPI
-    {
-
-
-        public YPinsAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        /// <summary>
-        /// Получение списка прикреплённых объектов
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YPins>> GetAsync(AuthStorage storage)
-        {
-            return new YGetPinsBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-        }
-
-
-    }
-}

YandexMusic.API/API/YPlaylistAPI.cs

@@ -0,0 +1,149 @@
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Models.Landing;
+using YandexMusic.API.Models.Landing.Entity.Entities;
+using YandexMusic.API.Models.Playlist;
+using YandexMusic.API.Models.Track;
+using YandexMusic.API.Requests.Playlist;
+
+namespace YandexMusic.API;
+
+/// <summary>API для взаимодействия с плейлистами.</summary>
+public class YPlaylistAPI : YCommonAPI
+{
+    /// <summary>Инициализирует новый экземпляр API плейлистов.</summary>
+    /// <param name="yandex">Экземпляр основного API.</param>
+    public YPlaylistAPI(YandexMusicApi yandex) : base(yandex) { }
+
+    /// <summary>Получает список персональных плейлистов с главной страницы.</summary>
+    /// <param name="storage">Хранилище авторизации.</param>
+    /// <returns>Список ответов с плейлистами.</returns>
+    public async Task<List<YResponse<YPlaylist>>> GetPersonalPlaylistsAsync(AuthStorage storage)
+    {
+        var landing = await api.Landing.GetAsync(storage, YLandingBlockType.PersonalPlaylists);
+        var block = landing.Result?.Blocks?.FirstOrDefault(b => b.Type == YLandingBlockType.PersonalPlaylists);
+        if (block?.Entities == null)
+            return new List<YResponse<YPlaylist>>();
+
+        var tasks = block.Entities
+            .OfType<YLandingEntityPersonalPlaylist>()
+            .Select(e => api.Playlist.GetAsync(storage, e.Data?.Data));
+
+        return new List<YResponse<YPlaylist>>(await Task.WhenAll(tasks));
+    }
+
+    /// <summary>Получает избранные плейлисты.</summary>
+    public Task<YResponse<List<YPlaylist>>> FavoritesAsync(AuthStorage storage)
+        => new YGetPlaylistFavoritesBuilder(api, storage).Build(null!).GetResponseAsync();
+
+    /// <summary>Получает плейлист дня.</summary>
+    public Task<YResponse<YPlaylist>> OfTheDayAsync(AuthStorage storage)
+        => GetPersonalPlaylistAsync(storage, YGeneratedPlaylistType.PlaylistOfTheDay);
+
+    /// <summary>Получает плейлист «Дежавю».</summary>
+    public Task<YResponse<YPlaylist>> DejaVuAsync(AuthStorage storage)
+        => GetPersonalPlaylistAsync(storage, YGeneratedPlaylistType.NeverHeard);
+
+    /// <summary>Получает плейлист «Премьера».</summary>
+    public Task<YResponse<YPlaylist>> PremiereAsync(AuthStorage storage)
+        => GetPersonalPlaylistAsync(storage, YGeneratedPlaylistType.RecentTracks);
+
+    /// <summary>Получает плейлист «Тайник».</summary>
+    public Task<YResponse<YPlaylist>> MissedAsync(AuthStorage storage)
+        => GetPersonalPlaylistAsync(storage, YGeneratedPlaylistType.MissedLikes);
+
+    /// <summary>Получает плейлист «Кинопоиск».</summary>
+    public Task<YResponse<YPlaylist>> KinopoiskAsync(AuthStorage storage)
+        => GetPersonalPlaylistAsync(storage, YGeneratedPlaylistType.Kinopoisk);
+
+    private async Task<YResponse<YPlaylist>> GetPersonalPlaylistAsync(AuthStorage storage, YGeneratedPlaylistType type)
+    {
+        var list = await GetPersonalPlaylistsAsync(storage);
+        return list.FirstOrDefault(e => string.Equals(e.Result?.GeneratedPlaylistType, type.ToString(), StringComparison.CurrentCultureIgnoreCase))
+            ?? throw new Exception($"Плейлист типа {type} не найден.");
+    }
+
+    /// <summary>Получает плейлист по идентификатору пользователя и типа.</summary>
+    public Task<YResponse<YPlaylist>> GetAsync(AuthStorage storage, string user, string kind)
+        => new YGetPlaylistBuilder(api, storage).Build((user, kind)).GetResponseAsync();
+
+    /// <summary>Получает плейлист по UUID.</summary>
+    public Task<YResponse<YPlaylist>> GetAsync(AuthStorage storage, string uuid)
+        => new YGetPlaylistByUuidBuilder(api, storage).Build(uuid).GetResponseAsync();
+
+    /// <summary>Получает несколько плейлистов по списку пар (пользователь, тип).</summary>
+    public Task<YResponse<List<YPlaylist>>> GetAsync(AuthStorage storage, IEnumerable<(string user, string kind)> ids)
+        => new YGetPlaylistsBuilder(api, storage).Build(ids).GetResponseAsync();
+
+    /// <summary>Получает плейлист по объекту плейлиста (обновляет его треки).</summary>
+    public Task<YResponse<YPlaylist>> GetAsync(AuthStorage storage, YPlaylist playlist)
+        => new YGetPlaylistBuilder(api, storage).Build((playlist.Owner.Uid, playlist.Kind)).GetResponseAsync();
+
+    /// <summary>Создаёт новый плейлист с заданным именем.</summary>
+    public Task<YResponse<YPlaylist>> CreateAsync(AuthStorage storage, string name)
+        => new YPlaylistCreateBuilder(api, storage).Build(name).GetResponseAsync();
+
+    /// <summary>Переименовывает плейлист.</summary>
+    public Task<YResponse<YPlaylist>> RenameAsync(AuthStorage storage, string kind, string name)
+        => new YPlaylistRenameBuilder(api, storage).Build((kind, name)).GetResponseAsync();
+
+    /// <summary>Переименовывает плейлист.</summary>
+    public Task<YResponse<YPlaylist>> RenameAsync(AuthStorage storage, YPlaylist playlist, string name)
+        => RenameAsync(storage, playlist.Kind, name);
+
+    /// <summary>Удаляет плейлист.</summary>
+    public async Task<bool> DeleteAsync(AuthStorage storage, string kind)
+    {
+        try
+        {
+            await new YPlaylistRemoveBuilder(api, storage).Build(kind).GetResponseAsync();
+            return true;
+        }
+        catch (Exception ex)
+        {
+            // Логирование ошибки можно добавить через ILogger
+            return false;
+        }
+    }
+
+    /// <summary>Удаляет плейлист.</summary>
+    public Task<bool> DeleteAsync(AuthStorage storage, YPlaylist playlist)
+        => DeleteAsync(storage, playlist.Kind);
+
+    /// <summary>Добавляет треки в начало плейлиста.</summary>
+    public async Task<YResponse<YPlaylist>> InsertTracksAsync(AuthStorage storage, YPlaylist playlist, IEnumerable<YTrack> tracks)
+    {
+        var change = await ChangePlaylistAsync(storage, playlist, new List<YPlaylistChange>
+        {
+            new()
+            {
+                Operation = YPlaylistChangeType.Insert,
+                At = 0,
+                Tracks = tracks.Select(t => t.GetKey())
+            }
+        });
+        return await GetAsync(storage, change.Result);
+    }
+
+    /// <summary>Удаляет треки из плейлиста.</summary>
+    public Task<YResponse<YPlaylist>> DeleteTracksAsync(AuthStorage storage, YPlaylist playlist, IEnumerable<YTrack> tracks)
+    {
+        var distinctTracks = tracks.Distinct().ToList();
+        var changes = distinctTracks
+            .Select(t => playlist.Tracks?.FindIndex(ct => ct.Track?.GetKey() == t.GetKey()) ?? -1)
+            .Where(i => i != -1)
+            .Select(i => new YPlaylistChange
+            {
+                Operation = YPlaylistChangeType.Delete,
+                From = i,
+                To = i + 1,
+                Tracks = new List<YTrackAlbumPair> { playlist.Tracks![i].Track!.GetKey() }
+            })
+            .ToList();
+
+        return ChangePlaylistAsync(storage, playlist, changes);
+    }
+
+    private Task<YResponse<YPlaylist>> ChangePlaylistAsync(AuthStorage storage, YPlaylist playlist, IEnumerable<YPlaylistChange> changes)
+        => new YPlaylistChangeBuilder(api, storage).Build((playlist, changes)).GetResponseAsync();
+}

YandexMusic.API/API/YPlaylistAPIAsync.cs

@@ -1,335 +0,0 @@
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Models.Landing;
-using YandexMusic.API.Models.Landing.Entity.Entities;
-using YandexMusic.API.Models.Playlist;
-using YandexMusic.API.Models.Track;
-using YandexMusic.API.Requests.Playlist;
-
-namespace YandexMusic.API
-{
-    /// <summary>
-    /// API для взамодействия с плейлистами
-    /// </summary>
-    public partial class YPlaylistAPI : YCommonAPI
-    {
-        #region Вспомогательные функции
-
-        /// <summary>
-        /// Получение персональных плейлистов
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="type">Тип</param>
-        /// <returns>Плейлист</returns>
-        private async Task<YResponse<YPlaylist>> GetPersonalPlaylist(AuthStorage storage, YGeneratedPlaylistType type)
-        {
-            List<YResponse<YPlaylist>> list = await GetPersonalPlaylistsAsync(storage);
-            return list.FirstOrDefault(e => string.Equals(e.Result.GeneratedPlaylistType, type.ToString(), StringComparison.CurrentCultureIgnoreCase));
-        }
-
-        /// <summary>
-        /// Изменение плейлиста
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="playlist">Плейлист</param>
-        /// <param name="changes">Список изменений</param>
-        /// <returns>Плейлист после изменений</returns>
-        private Task<YResponse<YPlaylist>> ChangePlaylist(AuthStorage storage, YPlaylist playlist, IEnumerable<YPlaylistChange> changes)
-        {
-            return new YPlaylistChangeBuilder(api, storage)
-                .Build((playlist, changes))
-                .GetResponseAsync();
-        }
-
-        private IEnumerable<YTrack> RemoveIdentical(IEnumerable<YTrack> tracks)
-        {
-            return tracks.Distinct();
-        }
-
-        #endregion Вспомогательные функции
-
-
-
-        public YPlaylistAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        #region Список с главной
-
-        /// <summary>
-        /// Получение списка персональных плейлистов
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public async Task<List<YResponse<YPlaylist>>> GetPersonalPlaylistsAsync(AuthStorage storage)
-        {
-            YResponse<YLanding> landing = await api.Landing.GetAsync(storage, YLandingBlockType.PersonalPlaylists);
-
-            IEnumerable<Task<YResponse<YPlaylist>>> tasks = landing
-                .Result
-                .Blocks
-                .FirstOrDefault(b => b.Type == YLandingBlockType.PersonalPlaylists)
-                ?.Entities
-                .Select(e => api.Playlist.GetAsync(storage, ((YLandingEntityPersonalPlaylist)e).Data?.Data));
-
-            return tasks == null
-                ? new List<YResponse<YPlaylist>>()
-                : new List<YResponse<YPlaylist>>(await Task.WhenAll(tasks));
-        }
-
-        #endregion Список с главной
-
-        #region Стандартные плейлисты
-
-        /// <summary>
-        /// Избранное
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YPlaylist>>> FavoritesAsync(AuthStorage storage)
-        {
-            return new YGetPlaylistFavoritesBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Плейлист дня
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> OfTheDayAsync(AuthStorage storage)
-        {
-            return GetPersonalPlaylist(storage, YGeneratedPlaylistType.PlaylistOfTheDay);
-        }
-
-        /// <summary>
-        /// Дежавю
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> DejaVuAsync(AuthStorage storage)
-        {
-            return GetPersonalPlaylist(storage, YGeneratedPlaylistType.NeverHeard);
-        }
-
-        /// <summary>
-        /// Премьера
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> PremiereAsync(AuthStorage storage)
-        {
-            return GetPersonalPlaylist(storage, YGeneratedPlaylistType.RecentTracks);
-        }
-
-        /// <summary>
-        /// Тайник
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> MissedAsync(AuthStorage storage)
-        {
-            return GetPersonalPlaylist(storage, YGeneratedPlaylistType.MissedLikes);
-        }
-
-        /// <summary>
-        /// Кинопоиск
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> KinopoiskAsync(AuthStorage storage)
-        {
-            return GetPersonalPlaylist(storage, YGeneratedPlaylistType.Kinopoisk);
-        }
-
-        #endregion Стандартные плейлисты
-
-        #region Получение плейлиста
-
-        /// <summary>
-        /// Получение плейлиста
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="user">Uid пользователя-владельца плейлиста</param>
-        /// <param name="kind">Тип</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> GetAsync(AuthStorage storage, string user, string kind)
-        {
-            return new YGetPlaylistBuilder(api, storage)
-                .Build((user, kind))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение плейлиста по uuid
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="uuid">uuid</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> GetAsync(AuthStorage storage, string uuid)
-        {
-            return new YGetPlaylistByUuidBuilder(api, storage)
-                .Build(uuid)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение плейлистов
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="ids">Список пар пользователь:тип</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YPlaylist>>> GetAsync(AuthStorage storage, IEnumerable<(string user, string kind)> ids)
-        {
-            return new YGetPlaylistsBuilder(api, storage)
-                .Build(ids)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение плейлиста
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="playlist">Описание плейлиста, для которого будут запрошены треки</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> GetAsync(AuthStorage storage, YPlaylist playlist)
-        {
-            return new YGetPlaylistBuilder(api, storage)
-                .Build((playlist.Owner.Uid, playlist.Kind))
-                .GetResponseAsync();
-        }
-
-        #endregion Получение плейлиста
-
-        #region Операции над плейлистами
-
-        /// <summary>
-        /// Создание
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="name">Заголовок</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> CreateAsync(AuthStorage storage, string name)
-        {
-            return new YPlaylistCreateBuilder(api, storage)
-                .Build(name)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Переименование
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="kinds">Идентификатор плейлиста</param>
-        /// <param name="name">Заголовок</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> RenameAsync(AuthStorage storage, string kinds, string name)
-        {
-            return new YPlaylistRenameBuilder(api, storage)
-                .Build((kinds, name))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Переименование
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="playlist">Плейлист</param>
-        /// <param name="name">Заголовок</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> RenameAsync(AuthStorage storage, YPlaylist playlist, string name)
-        {
-            return RenameAsync(storage, playlist.Kind, name);
-        }
-
-        /// <summary>
-        /// Удаление
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="kinds">Тип</param>
-        /// <returns></returns>
-        public async Task<bool> DeleteAsync(AuthStorage storage, string kinds)
-        {
-            try
-            {
-                await new YPlaylistRemoveBuilder(api, storage)
-                    .Build(kinds)
-                    .GetResponseAsync();
-
-                return true;
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine(ex);
-            }
-
-            return false;
-        }
-
-        /// <summary>
-        /// Удаление
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="playlist">Плейлист</param>
-        /// <returns></returns>
-        public Task<bool> DeleteAsync(AuthStorage storage, YPlaylist playlist)
-        {
-            return DeleteAsync(storage, playlist.Kind);
-        }
-
-        /// <summary>
-        /// Добавление трека
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="playlist">Плейлист</param>
-        /// <param name="tracks">Треки для добавления</param>
-        /// <returns></returns>
-        public async Task<YResponse<YPlaylist>> InsertTracksAsync(AuthStorage storage, YPlaylist playlist, IEnumerable<YTrack> tracks)
-        {
-            YResponse<YPlaylist> change = await ChangePlaylist(storage, playlist, new List<YPlaylistChange> {
-                    new() {
-                        Operation = YPlaylistChangeType.Insert,
-                        At = 0,
-                        Tracks = tracks.Select(t => t.GetKey())
-                    }
-                });
-
-            return await GetAsync(storage, change.Result);
-        }
-
-        /// <summary>
-        /// Удаление треков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="playlist">Плейлист</param>
-        /// <param name="tracks">Треки для удаления</param>
-        /// <returns></returns>
-        public Task<YResponse<YPlaylist>> DeleteTracksAsync(AuthStorage storage, YPlaylist playlist, IEnumerable<YTrack> tracks)
-        {
-            List<YPlaylistChange> changes = RemoveIdentical(tracks)
-                .Select(t => playlist.Tracks.Select(c => c.Track).ToList().IndexOf(t))
-                .Where(i => i != -1)
-                .Select(i =>
-                {
-                    YTrackContainer t = playlist.Tracks[i];
-                    return new YPlaylistChange
-                    {
-                        Operation = YPlaylistChangeType.Delete,
-                        From = i,
-                        To = i + 1,
-                        Tracks = new List<YTrackAlbumPair> {
-                            t.Track.GetKey()
-                        }
-                    };
-                })
-                .ToList();
-
-            return ChangePlaylist(storage, playlist, changes);
-        }
-
-        #endregion Операции над плейлистами
-
-
-    }
-}

YandexMusic.API/API/YQueueAPI.cs

@@ -0,0 +1,72 @@
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Models.Queue;
+using YandexMusic.API.Requests.Queue;
+
+namespace YandexMusic.API;
+
+/// <summary>
+/// API для взаимодействия с очередями
+/// </summary>
+public partial class YQueueAPI : YCommonAPI
+{
+    public YQueueAPI(YandexMusicApi yandex) : base(yandex)
+    {
+    }
+
+    /// <summary>
+    /// Получение всех очередей треков с разных устройств для синхронизации между ними
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="device">Устройство</param>
+    /// <returns></returns>
+    public Task<YResponse<YQueueItemsContainer>> ListAsync(AuthStorage storage, string? device = null)
+    {
+        return new YQueuesListBuilder(api, storage)
+            .Build(device)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение очереди
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="queueId">Идентификатор очереди</param>
+    /// <returns></returns>
+    public Task<YResponse<YQueue>> GetAsync(AuthStorage storage, string queueId)
+    {
+        return new YGetQueueBuilder(api, storage)
+            .Build(queueId)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Создание новой очереди треков
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="queue">Очередь треков</param>
+    /// <param name="device">Устройство</param>
+    /// <returns></returns>
+    public Task<YResponse<YNewQueue>> CreateAsync(AuthStorage storage, YQueue queue, string? device = null)
+    {
+        return new YQueueCreateBuilder(api, storage, device)
+            .Build(queue)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Установка текущего индекса проигрываемого трека в очереди треков
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="queueId">Идентификатор очереди</param>
+    /// <param name="currentIndex">Текущий индекс</param>
+    /// <param name="isInteractive">Флаг интерактивности</param>
+    /// <param name="device">Устройство</param>
+    /// <returns></returns>
+    public Task<YResponse<YUpdatedQueue>> UpdatePositionAsync(AuthStorage storage, string queueId, int currentIndex, bool isInteractive, string device = null)
+    {
+        return new YQueueUpdatePositionBuilder(api, storage, device)
+            .Build((queueId, currentIndex, isInteractive))
+            .GetResponseAsync();
+    }
+}

YandexMusic.API/API/YQueueAPIAsync.cs

@@ -1,73 +0,0 @@
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Models.Queue;
-using YandexMusic.API.Requests.Queue;
-
-namespace YandexMusic.API
-{
-    /// <summary>
-    /// API для взаимодействия с очередями
-    /// </summary>
-    public partial class YQueueAPI : YCommonAPI
-    {
-        public YQueueAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        /// <summary>
-        /// Получение всех очередей треков с разных устройств для синхронизации между ними
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="device">Устройство</param>
-        /// <returns></returns>
-        public Task<YResponse<YQueueItemsContainer>> ListAsync(AuthStorage storage, string device = null)
-        {
-            return new YQueuesListBuilder(api, storage)
-                .Build(device)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение очереди
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="queueId">Идентификатор очереди</param>
-        /// <returns></returns>
-        public Task<YResponse<YQueue>> GetAsync(AuthStorage storage, string queueId)
-        {
-            return new YGetQueueBuilder(api, storage)
-                .Build(queueId)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Создание новой очереди треков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="queue">Очередь треков</param>
-        /// <param name="device">Устройство</param>
-        /// <returns></returns>
-        public Task<YResponse<YNewQueue>> CreateAsync(AuthStorage storage, YQueue queue, string device = null)
-        {
-            return new YQueueCreateBuilder(api, storage, device)
-                .Build(queue)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Установка текущего индекса проигрываемого трека в очереди треков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="queueId">Идентификатор очереди</param>
-        /// <param name="currentIndex">Текущий индекс</param>
-        /// <param name="isInteractive">Флаг интерактивности</param>
-        /// <param name="device">Устройство</param>
-        /// <returns></returns>
-        public Task<YResponse<YUpdatedQueue>> UpdatePositionAsync(AuthStorage storage, string queueId, int currentIndex, bool isInteractive, string device = null)
-        {
-            return new YQueueUpdatePositionBuilder(api, storage, device)
-                .Build((queueId, currentIndex, isInteractive))
-                .GetResponseAsync();
-        }
-    }
-}

YandexMusic.API/API/YRadioAPI.cs

@@ -0,0 +1,113 @@
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Models.Radio;
+using YandexMusic.API.Models.Track;
+using YandexMusic.API.Requests.Radio;
+
+namespace YandexMusic.API;
+
+/// <summary>
+/// API для взаимодействия с радио
+/// </summary>
+public partial class YRadioAPI : YCommonAPI
+{
+    public YRadioAPI(YandexMusicApi yandex) : base(yandex)
+    {
+    }
+
+    /// <summary>
+    /// Получение списка рекомендованных радиостанций
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YResponse<YStationsDashboard>> GetStationsDashboardAsync(AuthStorage storage)
+    {
+        return new YGetStationsDashboardBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение списка радиостанций
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YStation>>> GetStationsAsync(AuthStorage storage)
+    {
+        return new YGetStationsBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение информации о радиостанции
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="type">Тип</param>
+    /// <param name="tag">Тэг</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YStation>>> GetStationAsync(AuthStorage storage, string type, string tag)
+    {
+        return new YGetStationBuilder(api, storage)
+            .Build((type, tag))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение информации о радиостанции
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="id">Идентификатор станции</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YStation>>> GetStationAsync(AuthStorage storage, YStationId id)
+    {
+        return GetStationAsync(storage, id.Type, id.Tag);
+    }
+
+    /// <summary>
+    /// Получение последовательности треков радиостанции
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="station">Радиостанция</param>
+    /// <param name="prevTrackId">Идентификатор предыдущего трека</param>
+    /// <returns></returns>
+    public Task<YResponse<YStationSequence>> GetStationTracksAsync(AuthStorage storage, YStation station, string prevTrackId = "")
+    {
+        return new YGetStationTracksBuilder(api, storage)
+            .Build((station.Station, prevTrackId))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Установка настроек подбора треков
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="station">Радиостанция</param>
+    /// <param name="settings">Настройки</param>
+    /// <returns></returns>
+    public Task<YResponse<string>> SetStationSettings2Async(AuthStorage storage, YStation station, YStationSettings2 settings)
+    {
+        return new YSetSettings2Builder(api, storage)
+            .Build((station.Station, settings))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Отправка обратной связи на действия при прослушивании радио
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="station">Радиостанция</param>
+    /// <param name="type">Тип обратной связи</param>
+    /// <param name="track">Трек</param>
+    /// <param name="batchId">Уникальный идентификатор партии треков. Возвращается при получении треков</param>
+    /// <param name="totalPlayedSeconds">Сколько было проиграно секунд трека перед действием</param>
+    /// <returns></returns>
+    public Task<string> SendStationFeedBackAsync(AuthStorage storage, YStation station, YStationFeedbackType type, YTrack track = null, string batchId = "", double totalPlayedSeconds = 0)
+    {
+        return new YSetStationFeedbackBuilder(api, storage)
+            .Build((type, station, track, batchId, totalPlayedSeconds))
+            .GetResponseAsync();
+    }
+
+
+}

YandexMusic.API/API/YRadioAPIAsync.cs

@@ -1,116 +0,0 @@
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Models.Radio;
-using YandexMusic.API.Models.Track;
-using YandexMusic.API.Requests.Radio;
-
-namespace YandexMusic.API
-{
-    /// <summary>
-    /// API для взаимодействия с радио
-    /// </summary>
-    public partial class YRadioAPI : YCommonAPI
-    {
-
-
-        public YRadioAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        /// <summary>
-        /// Получение списка рекомендованных радиостанций
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YStationsDashboard>> GetStationsDashboardAsync(AuthStorage storage)
-        {
-            return new YGetStationsDashboardBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение списка радиостанций
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YStation>>> GetStationsAsync(AuthStorage storage)
-        {
-            return new YGetStationsBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение информации о радиостанции
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="type">Тип</param>
-        /// <param name="tag">Тэг</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YStation>>> GetStationAsync(AuthStorage storage, string type, string tag)
-        {
-            return new YGetStationBuilder(api, storage)
-                .Build((type, tag))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение информации о радиостанции
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="id">Идентификатор станции</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YStation>>> GetStationAsync(AuthStorage storage, YStationId id)
-        {
-            return GetStationAsync(storage, id.Type, id.Tag);
-        }
-
-        /// <summary>
-        /// Получение последовательности треков радиостанции
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="station">Радиостанция</param>
-        /// <param name="prevTrackId">Идентификатор предыдущего трека</param>
-        /// <returns></returns>
-        public Task<YResponse<YStationSequence>> GetStationTracksAsync(AuthStorage storage, YStation station, string prevTrackId = "")
-        {
-            return new YGetStationTracksBuilder(api, storage)
-                .Build((station.Station, prevTrackId))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Установка настроек подбора треков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="station">Радиостанция</param>
-        /// <param name="settings">Настройки</param>
-        /// <returns></returns>
-        public Task<YResponse<string>> SetStationSettings2Async(AuthStorage storage, YStation station, YStationSettings2 settings)
-        {
-            return new YSetSettings2Builder(api, storage)
-                .Build((station.Station, settings))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Отправка обратной связи на действия при прослушивании радио
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="station">Радиостанция</param>
-        /// <param name="type">Тип обратной связи</param>
-        /// <param name="track">Трек</param>
-        /// <param name="batchId">Уникальный идентификатор партии треков. Возвращается при получении треков</param>
-        /// <param name="totalPlayedSeconds">Сколько было проиграно секунд трека перед действием</param>
-        /// <returns></returns>
-        public Task<string> SendStationFeedBackAsync(AuthStorage storage, YStation station, YStationFeedbackType type, YTrack track = null, string batchId = "", double totalPlayedSeconds = 0)
-        {
-            return new YSetStationFeedbackBuilder(api, storage)
-                .Build((type, station, track, batchId, totalPlayedSeconds))
-                .GetResponseAsync();
-        }
-
-
-    }
-}

YandexMusic.API/API/YSearchAPI.cs

@@ -0,0 +1,139 @@
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Models.Search;
+using YandexMusic.API.Requests.Search;
+
+namespace YandexMusic.API;
+
+/// <summary>
+/// API для поиска
+/// </summary>
+public partial class YSearchAPI : YCommonAPI
+{
+
+    public YSearchAPI(YandexMusicApi yandex) : base(yandex)
+    {
+    }
+
+    /// <summary>
+    /// Поиск по трекам
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="trackName">Имя трека</param>
+    /// <param name="pageNumber">Номер страницы</param>
+    /// <param name="pageSize">Размер страницы</param>
+    /// <returns></returns>
+    public Task<YResponse<YSearch>> TrackAsync(AuthStorage storage, string trackName, int pageNumber = 0, int pageSize = 20)
+    {
+        return SearchAsync(storage, trackName, YSearchType.Track, pageNumber, pageSize);
+    }
+
+    /// <summary>
+    /// Поиск по альбомам
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="albumName">Имя альбома</param>
+    /// <param name="pageNumber">Номер страницы</param>
+    /// <param name="pageSize">Размер страницы</param>
+    /// <returns></returns>
+    public Task<YResponse<YSearch>> AlbumsAsync(AuthStorage storage, string albumName, int pageNumber = 0, int pageSize = 20)
+    {
+        return SearchAsync(storage, albumName, YSearchType.Album, pageNumber, pageSize);
+    }
+
+    /// <summary>
+    /// Поиск по артисту
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="artistName">Имя артиста</param>
+    /// <param name="pageNumber">Номер страницы</param>
+    /// <param name="pageSize">Размер страницы</param>
+    /// <returns></returns>
+    public Task<YResponse<YSearch>> ArtistAsync(AuthStorage storage, string artistName, int pageNumber = 0, int pageSize = 20)
+    {
+        return SearchAsync(storage, artistName, YSearchType.Artist, pageNumber, pageSize);
+    }
+
+    /// <summary>
+    /// Поиск по плейлистам
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="playlistName">Имя плейлиста</param>
+    /// <param name="pageNumber">Номер страницы</param>
+    /// <param name="pageSize">Размер страницы</param>
+    /// <returns></returns>
+    public Task<YResponse<YSearch>> PlaylistAsync(AuthStorage storage, string playlistName, int pageNumber = 0, int pageSize = 20)
+    {
+        return SearchAsync(storage, playlistName, YSearchType.Playlist, pageNumber, pageSize);
+    }
+
+    /// <summary>
+    /// Поиск по плейлистам
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="podcastName">Имя подкаста</param>
+    /// <param name="pageNumber">Номер страницы</param>
+    /// <param name="pageSize">Размер страницы</param>
+    /// <returns></returns>
+    public Task<YResponse<YSearch>> PodcastEpisodeAsync(AuthStorage storage, string podcastName, int pageNumber = 0, int pageSize = 20)
+    {
+        return SearchAsync(storage, podcastName, YSearchType.PodcastEpisode, pageNumber, pageSize);
+    }
+
+    /// <summary>
+    /// Поиск по видео
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="videoName">Имя видео</param>
+    /// <param name="pageNumber">Номер страницы</param>
+    /// <param name="pageSize">Размер страницы</param>
+    /// <returns></returns>
+    public Task<YResponse<YSearch>> VideosAsync(AuthStorage storage, string videoName, int pageNumber = 0, int pageSize = 20)
+    {
+        return SearchAsync(storage, videoName, YSearchType.Video, pageNumber, pageSize);
+    }
+
+    /// <summary>
+    /// Поиск по пользователям
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="userName">Имя пользователя</param>
+    /// <param name="pageNumber">Номер страницы</param>
+    /// <param name="pageSize">Размер страницы</param>
+    /// <returns></returns>
+    public Task<YResponse<YSearch>> UsersAsync(AuthStorage storage, string userName, int pageNumber = 0, int pageSize = 20)
+    {
+        return SearchAsync(storage, userName, YSearchType.User, pageNumber, pageSize);
+    }
+
+    /// <summary>
+    /// Поиск
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="searchText">Поисковый запрос</param>
+    /// <param name="searchType">Тип поиска</param>
+    /// <param name="page">Страница</param>
+    /// <param name="pageSize">Размер страницы</param>
+    /// <returns></returns>
+    public Task<YResponse<YSearch>> SearchAsync(AuthStorage storage, string searchText, YSearchType searchType, int page = 0, int pageSize = 20)
+    {
+        return new YSearchBuilder(api, storage)
+            .Build((searchText, searchType, page, pageSize))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Подсказка
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="searchText">Поисковый запрос</param>
+    /// <returns></returns>
+    public Task<YResponse<YSearchSuggest>> SuggestAsync(AuthStorage storage, string searchText)
+    {
+        return new YSearchSuggestBuilder(api, storage)
+            .Build(searchText)
+            .GetResponseAsync();
+    }
+
+
+}

YandexMusic.API/API/YSearchAPIAsync.cs

@@ -1,141 +0,0 @@
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Models.Search;
-using YandexMusic.API.Requests.Search;
-
-namespace YandexMusic.API
-{
-    /// <summary>
-    /// API для поиска
-    /// </summary>
-    public partial class YSearchAPI : YCommonAPI
-    {
-
-
-        public YSearchAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        /// <summary>
-        /// Поиск по трекам
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="trackName">Имя трека</param>
-        /// <param name="pageNumber">Номер страницы</param>
-        /// <param name="pageSize">Размер страницы</param>
-        /// <returns></returns>
-        public Task<YResponse<YSearch>> TrackAsync(AuthStorage storage, string trackName, int pageNumber = 0, int pageSize = 20)
-        {
-            return SearchAsync(storage, trackName, YSearchType.Track, pageNumber, pageSize);
-        }
-
-        /// <summary>
-        /// Поиск по альбомам
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="albumName">Имя альбома</param>
-        /// <param name="pageNumber">Номер страницы</param>
-        /// <param name="pageSize">Размер страницы</param>
-        /// <returns></returns>
-        public Task<YResponse<YSearch>> AlbumsAsync(AuthStorage storage, string albumName, int pageNumber = 0, int pageSize = 20)
-        {
-            return SearchAsync(storage, albumName, YSearchType.Album, pageNumber, pageSize);
-        }
-
-        /// <summary>
-        /// Поиск по артисту
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="artistName">Имя артиста</param>
-        /// <param name="pageNumber">Номер страницы</param>
-        /// <param name="pageSize">Размер страницы</param>
-        /// <returns></returns>
-        public Task<YResponse<YSearch>> ArtistAsync(AuthStorage storage, string artistName, int pageNumber = 0, int pageSize = 20)
-        {
-            return SearchAsync(storage, artistName, YSearchType.Artist, pageNumber, pageSize);
-        }
-
-        /// <summary>
-        /// Поиск по плейлистам
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="playlistName">Имя плейлиста</param>
-        /// <param name="pageNumber">Номер страницы</param>
-        /// <param name="pageSize">Размер страницы</param>
-        /// <returns></returns>
-        public Task<YResponse<YSearch>> PlaylistAsync(AuthStorage storage, string playlistName, int pageNumber = 0, int pageSize = 20)
-        {
-            return SearchAsync(storage, playlistName, YSearchType.Playlist, pageNumber, pageSize);
-        }
-
-        /// <summary>
-        /// Поиск по плейлистам
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="podcastName">Имя подкаста</param>
-        /// <param name="pageNumber">Номер страницы</param>
-        /// <param name="pageSize">Размер страницы</param>
-        /// <returns></returns>
-        public Task<YResponse<YSearch>> PodcastEpisodeAsync(AuthStorage storage, string podcastName, int pageNumber = 0, int pageSize = 20)
-        {
-            return SearchAsync(storage, podcastName, YSearchType.PodcastEpisode, pageNumber, pageSize);
-        }
-
-        /// <summary>
-        /// Поиск по видео
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="videoName">Имя видео</param>
-        /// <param name="pageNumber">Номер страницы</param>
-        /// <param name="pageSize">Размер страницы</param>
-        /// <returns></returns>
-        public Task<YResponse<YSearch>> VideosAsync(AuthStorage storage, string videoName, int pageNumber = 0, int pageSize = 20)
-        {
-            return SearchAsync(storage, videoName, YSearchType.Video, pageNumber, pageSize);
-        }
-
-        /// <summary>
-        /// Поиск по пользователям
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="userName">Имя пользователя</param>
-        /// <param name="pageNumber">Номер страницы</param>
-        /// <param name="pageSize">Размер страницы</param>
-        /// <returns></returns>
-        public Task<YResponse<YSearch>> UsersAsync(AuthStorage storage, string userName, int pageNumber = 0, int pageSize = 20)
-        {
-            return SearchAsync(storage, userName, YSearchType.User, pageNumber, pageSize);
-        }
-
-        /// <summary>
-        /// Поиск
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="searchText">Поисковый запрос</param>
-        /// <param name="searchType">Тип поиска</param>
-        /// <param name="page">Страница</param>
-        /// <param name="pageSize">Размер страницы</param>
-        /// <returns></returns>
-        public Task<YResponse<YSearch>> SearchAsync(AuthStorage storage, string searchText, YSearchType searchType, int page = 0, int pageSize = 20)
-        {
-            return new YSearchBuilder(api, storage)
-                .Build((searchText, searchType, page, pageSize))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Подсказка
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="searchText">Поисковый запрос</param>
-        /// <returns></returns>
-        public Task<YResponse<YSearchSuggest>> SuggestAsync(AuthStorage storage, string searchText)
-        {
-            return new YSearchSuggestBuilder(api, storage)
-                .Build(searchText)
-                .GetResponseAsync();
-        }
-
-
-    }
-}

YandexMusic.API/API/YTrackAPI.cs

@@ -0,0 +1,307 @@
+using System.Security.Cryptography;
+using System.Text;
+
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Models.Track;
+using YandexMusic.API.Requests.Track;
+
+namespace YandexMusic.API;
+
+/// <summary>
+/// API для взаимодействия с треками
+/// </summary>
+public partial class YTrackAPI : YCommonAPI
+{
+    #region Вспомогательные функции
+
+    private string BuildLinkForDownload(YTrackDownloadInfo mainDownloadResponse, YStorageDownloadFile storageDownload)
+    {
+        string path = storageDownload.Path;
+        string host = storageDownload.Host;
+        string ts = storageDownload.Ts;
+        string s = storageDownload.S;
+        string codec = mainDownloadResponse.Codec;
+
+        string secret = $"XGRlBW9FXlekgbPrRHuSiA{path.Substring(1, path.Length - 1)}{s}";
+        MD5 md5 = MD5.Create();
+        byte[] md5Hash = md5.ComputeHash(Encoding.UTF8.GetBytes(secret));
+        HMACSHA1 hmacsha1 = new();
+        byte[] hmasha1Hash = hmacsha1.ComputeHash(md5Hash);
+        string sign = BitConverter.ToString(hmasha1Hash).Replace("-", "").ToLower();
+
+        string link = $"https://{host}/get-{codec}/{sign}/{ts}{path}";
+
+        return link;
+    }
+
+    #endregion Вспомогательные функции
+
+
+
+    public YTrackAPI(YandexMusicApi yandex) : base(yandex)
+    {
+    }
+
+    /// <summary>
+    /// Получение треков
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="trackId">Идентификатор трека</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YTrack>>> GetAsync(AuthStorage storage, string trackId)
+    {
+        return new YGetTracksBuilder(api, storage)
+            .Build(new[] { trackId })
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение треков
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="trackIds">Идентификаторы треков</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YTrack>>> GetAsync(AuthStorage storage, IEnumerable<string> trackIds)
+    {
+        return new YGetTracksBuilder(api, storage)
+            .Build(trackIds)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение метаданных для загрузки
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="trackKey">Ключ трека в формате {идентифактор трека:идентификатор альбома}</param>
+    /// <param name="direct">Должен ли ответ содержать прямую ссылку на загрузку</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YTrackDownloadInfo>>> GetMetadataForDownloadAsync(AuthStorage storage, string trackKey, bool direct = false)
+    {
+        return new YTrackDownloadInfoBuilder(api, storage)
+            .Build((trackKey, direct))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение метаданных для загрузки
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <param name="direct">Должен ли ответ содержать прямую ссылку на загрузку</param>
+    /// <returns></returns>
+    public Task<YResponse<List<YTrackDownloadInfo>>> GetMetadataForDownloadAsync(AuthStorage storage, YTrack track, bool direct = false)
+    {
+        return GetMetadataForDownloadAsync(storage, track.GetKey().ToString(), direct);
+    }
+
+    /// <summary>
+    /// Получение информации для формирования ссылки для загрузки
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="metadataInfo">Метаданные для загрузки</param>
+    /// <returns></returns>
+    public Task<YStorageDownloadFile> GetDownloadFileInfoAsync(AuthStorage storage, YTrackDownloadInfo metadataInfo)
+    {
+        return new YStorageDownloadFileBuilder(api, storage)
+            .Build(metadataInfo.DownloadInfoUrl)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение ссылки для загрузки
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="trackKey">Ключ трека в формате {идентификатор трека:идентификатор альбома}</param>
+    /// <returns></returns>
+    public async Task<string> GetFileLinkAsync(AuthStorage storage, string trackKey)
+    {
+        YResponse<List<YTrackDownloadInfo>> meta = await GetMetadataForDownloadAsync(storage, trackKey);
+        YTrackDownloadInfo info = meta.Result
+            .OrderByDescending(i => i.BitrateInKbps)
+            .First(m => m.Codec == "mp3");
+        YStorageDownloadFile storageDownload = await GetDownloadFileInfoAsync(storage, info);
+        return BuildLinkForDownload(info, storageDownload);
+    }
+
+    /// <summary>
+    /// Получение ссылки для загрузки
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <returns></returns>
+    public Task<string> GetFileLinkAsync(AuthStorage storage, YTrack track)
+    {
+        return GetFileLinkAsync(storage, track.GetKey().ToString());
+    }
+
+    /// <summary>
+    /// Отправка текущего состояния прослушиваемого трека
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <param name="from">Наименования клиента, с которого происходит прослушивание</param>
+    /// <param name="fromCache">Проигрывается ли трек с кеша</param>
+    /// <param name="playId">Уникальный идентификатор проигрывания</param>
+    /// <param name="playlistId">Уникальный идентификатор плейлиста, если таковой прослушивается</param>
+    /// <param name="totalPlayedSeconds">Сколько было всего воспроизведено трека в секундах</param>
+    /// <param name="endPositionSeconds">Окончательное значение воспроизведенных секунд</param>
+    /// </summary>
+    /// <returns></returns>
+    public Task<string> SendPlayTrackInfoAsync(AuthStorage storage, YTrack track, string from, bool fromCache = false, string playId = "", string playlistId = "", double totalPlayedSeconds = 0, double endPositionSeconds = 0)
+    {
+        return new YSendTrackInfoBuilder(api, storage)
+            .Build((track, from, fromCache, playId, playlistId, totalPlayedSeconds, endPositionSeconds))
+            .GetResponseAsync();
+    }
+
+    #region GetSupplement
+
+    /// <summary>
+    /// Получение дополнительной информации для трека
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="trackId">Идентификатор трека</param>
+    /// <returns></returns>
+    public Task<YResponse<YTrackSupplement>> GetSupplementAsync(AuthStorage storage, string trackId)
+    {
+        return new YGetTrackSupplementBuilder(api, storage)
+            .Build(trackId)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение дополнительной информации для трека
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <returns></returns>
+    public Task<YResponse<YTrackSupplement>> GetSupplementAsync(AuthStorage storage, YTrack track)
+    {
+        return new YGetTrackSupplementBuilder(api, storage)
+            .Build(track.GetKey().ToString())
+            .GetResponseAsync();
+    }
+
+    #endregion GetSupplement
+
+    #region GetSimilar
+
+    /// <summary>
+    /// Получение похожих треков
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="trackId">Идентификатор трека</param>
+    /// <returns></returns>
+    public Task<YResponse<YTrackSimilar>> GetSimilarAsync(AuthStorage storage, string trackId)
+    {
+        return new YGetTrackSimilarBuilder(api, storage)
+            .Build(trackId)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение похожих треков
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <returns></returns>
+    public Task<YResponse<YTrackSimilar>> GetSimilarAsync(AuthStorage storage, YTrack track)
+    {
+        return new YGetTrackSimilarBuilder(api, storage)
+            .Build(track.GetKey().ToString())
+            .GetResponseAsync();
+    }
+
+    #endregion GetSimilar
+
+    #region Получение данных трека
+
+    #region В файл
+
+    /// <summary>
+    /// Выгрузка в файл
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="trackKey">Ключ трека в формате {идентификатор трека:идентификатор альбома}</param>
+    /// <param name="filePath">Путь для файла</param>
+    public async Task ExtractToFileAsync(AuthStorage storage, string trackKey, string filePath)
+    {
+        string url = await GetFileLinkAsync(storage, trackKey);
+        await new DataDownloader(storage).ToFile(url, filePath);
+    }
+
+    /// <summary>
+    /// Выгрузка в файл
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <param name="filePath">Путь для файла</param>
+    public Task ExtractToFileAsync(AuthStorage storage, YTrack track, string filePath)
+    {
+        return ExtractToFileAsync(storage, track.GetKey().ToString(), filePath);
+    }
+
+    #endregion В файл
+
+    #region В массив байт
+
+    /// <summary>
+    /// Получение двоичного массива данных
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="trackKey">Ключ трека в формате {идентификатор трека:идентификатор альбома}</param>
+    /// <returns></returns>
+    public async Task<byte[]> ExtractDataAsync(AuthStorage storage, string trackKey)
+    {
+        string url = await GetFileLinkAsync(storage, trackKey);
+        return await new DataDownloader(storage).AsBytes(url);
+    }
+
+    /// <summary>
+    /// Получение двоичного массива данных
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <returns></returns>
+    public Task<byte[]> ExtractDataAsync(AuthStorage storage, YTrack track)
+    {
+        return ExtractDataAsync(storage, track.GetKey().ToString());
+    }
+
+    #endregion В массив байт
+
+    #region В поток
+
+    /// <summary>
+    /// Получение потока данных
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="trackKey">Ключ трека в формате {идентификатор трека:идентификатор альбома}</param>
+    /// <param name="httpCompletionOption">Параметры передачи управления при http запросе</param>
+    /// <returns></returns>
+    public async Task<Stream> ExtractStreamAsync(AuthStorage storage, string trackKey,
+        HttpCompletionOption httpCompletionOption = HttpCompletionOption.ResponseContentRead)
+    {
+        string url = await GetFileLinkAsync(storage, trackKey);
+        return await new DataDownloader(storage).AsStream(url, httpCompletionOption);
+    }
+
+    /// <summary>
+    /// Получение потока данных
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="track">Трек</param>
+    /// <param name="httpCompletionOption">Параметры передачи управления при http запросе</param>
+    /// <returns></returns>
+    public Task<Stream> ExtractStreamAsync(AuthStorage storage, YTrack track,
+        HttpCompletionOption httpCompletionOption = HttpCompletionOption.ResponseContentRead)
+    {
+        return ExtractStreamAsync(storage, track.GetKey().ToString(), httpCompletionOption);
+    }
+
+    #endregion В поток
+
+    #endregion Получение данных трека
+
+
+}

YandexMusic.API/API/YTrackAPIAsync.cs

@@ -1,308 +0,0 @@
-using System.Security.Cryptography;
-using System.Text;
-
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Models.Track;
-using YandexMusic.API.Requests.Track;
-
-namespace YandexMusic.API
-{
-    /// <summary>
-    /// API для взаимодействия с треками
-    /// </summary>
-    public partial class YTrackAPI : YCommonAPI
-    {
-        #region Вспомогательные функции
-
-        private string BuildLinkForDownload(YTrackDownloadInfo mainDownloadResponse, YStorageDownloadFile storageDownload)
-        {
-            string path = storageDownload.Path;
-            string host = storageDownload.Host;
-            string ts = storageDownload.Ts;
-            string s = storageDownload.S;
-            string codec = mainDownloadResponse.Codec;
-
-            string secret = $"XGRlBW9FXlekgbPrRHuSiA{path.Substring(1, path.Length - 1)}{s}";
-            MD5 md5 = MD5.Create();
-            byte[] md5Hash = md5.ComputeHash(Encoding.UTF8.GetBytes(secret));
-            HMACSHA1 hmacsha1 = new();
-            byte[] hmasha1Hash = hmacsha1.ComputeHash(md5Hash);
-            string sign = BitConverter.ToString(hmasha1Hash).Replace("-", "").ToLower();
-
-            string link = $"https://{host}/get-{codec}/{sign}/{ts}{path}";
-
-            return link;
-        }
-
-        #endregion Вспомогательные функции
-
-
-
-        public YTrackAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        /// <summary>
-        /// Получение треков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="trackId">Идентификатор трека</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YTrack>>> GetAsync(AuthStorage storage, string trackId)
-        {
-            return new YGetTracksBuilder(api, storage)
-                .Build(new[] { trackId })
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение треков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="trackIds">Идентификаторы треков</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YTrack>>> GetAsync(AuthStorage storage, IEnumerable<string> trackIds)
-        {
-            return new YGetTracksBuilder(api, storage)
-                .Build(trackIds)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение метаданных для загрузки
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="trackKey">Ключ трека в формате {идентифактор трека:идентификатор альбома}</param>
-        /// <param name="direct">Должен ли ответ содержать прямую ссылку на загрузку</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YTrackDownloadInfo>>> GetMetadataForDownloadAsync(AuthStorage storage, string trackKey, bool direct = false)
-        {
-            return new YTrackDownloadInfoBuilder(api, storage)
-                .Build((trackKey, direct))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение метаданных для загрузки
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <param name="direct">Должен ли ответ содержать прямую ссылку на загрузку</param>
-        /// <returns></returns>
-        public Task<YResponse<List<YTrackDownloadInfo>>> GetMetadataForDownloadAsync(AuthStorage storage, YTrack track, bool direct = false)
-        {
-            return GetMetadataForDownloadAsync(storage, track.GetKey().ToString(), direct);
-        }
-
-        /// <summary>
-        /// Получение информации для формирования ссылки для загрузки
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="metadataInfo">Метаданные для загрузки</param>
-        /// <returns></returns>
-        public Task<YStorageDownloadFile> GetDownloadFileInfoAsync(AuthStorage storage, YTrackDownloadInfo metadataInfo)
-        {
-            return new YStorageDownloadFileBuilder(api, storage)
-                .Build(metadataInfo.DownloadInfoUrl)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение ссылки для загрузки
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="trackKey">Ключ трека в формате {идентификатор трека:идентификатор альбома}</param>
-        /// <returns></returns>
-        public async Task<string> GetFileLinkAsync(AuthStorage storage, string trackKey)
-        {
-            YResponse<List<YTrackDownloadInfo>> meta = await GetMetadataForDownloadAsync(storage, trackKey);
-            YTrackDownloadInfo info = meta.Result
-                .OrderByDescending(i => i.BitrateInKbps)
-                .First(m => m.Codec == "mp3");
-            YStorageDownloadFile storageDownload = await GetDownloadFileInfoAsync(storage, info);
-            return BuildLinkForDownload(info, storageDownload);
-        }
-
-        /// <summary>
-        /// Получение ссылки для загрузки
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <returns></returns>
-        public Task<string> GetFileLinkAsync(AuthStorage storage, YTrack track)
-        {
-            return GetFileLinkAsync(storage, track.GetKey().ToString());
-        }
-
-        /// <summary>
-        /// Отправка текущего состояния прослушиваемого трека
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <param name="from">Наименования клиента, с которого происходит прослушивание</param>
-        /// <param name="fromCache">Проигрывается ли трек с кеша</param>
-        /// <param name="playId">Уникальный идентификатор проигрывания</param>
-        /// <param name="playlistId">Уникальный идентификатор плейлиста, если таковой прослушивается</param>
-        /// <param name="totalPlayedSeconds">Сколько было всего воспроизведено трека в секундах</param>
-        /// <param name="endPositionSeconds">Окончательное значение воспроизведенных секунд</param>
-        /// </summary>
-        /// <returns></returns>
-        public Task<string> SendPlayTrackInfoAsync(AuthStorage storage, YTrack track, string from, bool fromCache = false, string playId = "", string playlistId = "", double totalPlayedSeconds = 0, double endPositionSeconds = 0)
-        {
-            return new YSendTrackInfoBuilder(api, storage)
-                .Build((track, from, fromCache, playId, playlistId, totalPlayedSeconds, endPositionSeconds))
-                .GetResponseAsync();
-        }
-
-        #region GetSupplement
-
-        /// <summary>
-        /// Получение дополнительной информации для трека
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="trackId">Идентификатор трека</param>
-        /// <returns></returns>
-        public Task<YResponse<YTrackSupplement>> GetSupplementAsync(AuthStorage storage, string trackId)
-        {
-            return new YGetTrackSupplementBuilder(api, storage)
-                .Build(trackId)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение дополнительной информации для трека
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <returns></returns>
-        public Task<YResponse<YTrackSupplement>> GetSupplementAsync(AuthStorage storage, YTrack track)
-        {
-            return new YGetTrackSupplementBuilder(api, storage)
-                .Build(track.GetKey().ToString())
-                .GetResponseAsync();
-        }
-
-        #endregion GetSupplement
-
-        #region GetSimilar
-
-        /// <summary>
-        /// Получение похожих треков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="trackId">Идентификатор трека</param>
-        /// <returns></returns>
-        public Task<YResponse<YTrackSimilar>> GetSimilarAsync(AuthStorage storage, string trackId)
-        {
-            return new YGetTrackSimilarBuilder(api, storage)
-                .Build(trackId)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение похожих треков
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <returns></returns>
-        public Task<YResponse<YTrackSimilar>> GetSimilarAsync(AuthStorage storage, YTrack track)
-        {
-            return new YGetTrackSimilarBuilder(api, storage)
-                .Build(track.GetKey().ToString())
-                .GetResponseAsync();
-        }
-
-        #endregion GetSimilar
-
-        #region Получение данных трека
-
-        #region В файл
-
-        /// <summary>
-        /// Выгрузка в файл
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="trackKey">Ключ трека в формате {идентификатор трека:идентификатор альбома}</param>
-        /// <param name="filePath">Путь для файла</param>
-        public async Task ExtractToFileAsync(AuthStorage storage, string trackKey, string filePath)
-        {
-            string url = await GetFileLinkAsync(storage, trackKey);
-            await new DataDownloader(storage).ToFile(url, filePath);
-        }
-
-        /// <summary>
-        /// Выгрузка в файл
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <param name="filePath">Путь для файла</param>
-        public Task ExtractToFileAsync(AuthStorage storage, YTrack track, string filePath)
-        {
-            return ExtractToFileAsync(storage, track.GetKey().ToString(), filePath);
-        }
-
-        #endregion В файл
-
-        #region В массив байт
-
-        /// <summary>
-        /// Получение двоичного массива данных
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="trackKey">Ключ трека в формате {идентификатор трека:идентификатор альбома}</param>
-        /// <returns></returns>
-        public async Task<byte[]> ExtractDataAsync(AuthStorage storage, string trackKey)
-        {
-            string url = await GetFileLinkAsync(storage, trackKey);
-            return await new DataDownloader(storage).AsBytes(url);
-        }
-
-        /// <summary>
-        /// Получение двоичного массива данных
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <returns></returns>
-        public Task<byte[]> ExtractDataAsync(AuthStorage storage, YTrack track)
-        {
-            return ExtractDataAsync(storage, track.GetKey().ToString());
-        }
-
-        #endregion В массив байт
-
-        #region В поток
-
-        /// <summary>
-        /// Получение потока данных
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="trackKey">Ключ трека в формате {идентификатор трека:идентификатор альбома}</param>
-        /// <param name="httpCompletionOption">Параметры передачи управления при http запросе</param>
-        /// <returns></returns>
-        public async Task<Stream> ExtractStreamAsync(AuthStorage storage, string trackKey,
-            HttpCompletionOption httpCompletionOption = HttpCompletionOption.ResponseContentRead)
-        {
-            string url = await GetFileLinkAsync(storage, trackKey);
-            return await new DataDownloader(storage).AsStream(url, httpCompletionOption);
-        }
-
-        /// <summary>
-        /// Получение потока данных
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="track">Трек</param>
-        /// <param name="httpCompletionOption">Параметры передачи управления при http запросе</param>
-        /// <returns></returns>
-        public Task<Stream> ExtractStreamAsync(AuthStorage storage, YTrack track,
-            HttpCompletionOption httpCompletionOption = HttpCompletionOption.ResponseContentRead)
-        {
-            return ExtractStreamAsync(storage, track.GetKey().ToString(), httpCompletionOption);
-        }
-
-        #endregion В поток
-
-        #endregion Получение данных трека
-
-
-    }
-}

YandexMusic.API/API/YUgcAPI.cs

@@ -0,0 +1,71 @@
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Models.Playlist;
+using YandexMusic.API.Models.Ugc;
+using YandexMusic.API.Requests.Ugc;
+
+namespace YandexMusic.API;
+
+public partial class YUgcAPI : YCommonAPI
+{
+    public YUgcAPI(YandexMusicApi yandex) : base(yandex)
+    {
+    }
+
+    /// <summary>
+    /// Получение ссылки на загрузчик трека
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="playlist">Плейлист, куда будет загружен трек</param>
+    /// <param name="fileName">Название файла для загрузки</param>
+    public Task<YUgcUpload> GetUgcUploadLinkAsync(AuthStorage storage, YPlaylist playlist, string fileName)
+    {
+        return new YUgcGetUploadLinkBuilder(api, storage)
+            .Build((playlist, fileName))
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Загрузка трека из файла
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="uploadLink">Ссылка на балансировщик для загрузки, можно получить из GetUgcUploadLinkAsync</param>
+    /// <param name="filePath">Загружаемый файл</param>
+    public Task<YResponse<string>> UploadUgcTrackAsync(AuthStorage storage, string uploadLink, string filePath)
+    {
+        if (!File.Exists(filePath))
+            throw new FileNotFoundException("Файл для загрузки не существует.", filePath);
+
+        return UploadUgcTrackAsync(storage, uploadLink, File.Open(filePath, FileMode.Open));
+    }
+
+    /// <summary>
+    /// Загрузка трека из потока
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="uploadLink">Ссылка на балансировщик для загрузки, можно получить из GetUgcUploadLinkAsync</param>
+    /// <param name="stream">Поток с данными для загрузки</param>
+    public Task<YResponse<string>> UploadUgcTrackAsync(AuthStorage storage, string uploadLink, Stream stream)
+    {
+        if (stream == null)
+            throw new NullReferenceException("Пустая ссылка на поток загрузки.");
+
+        using MemoryStream ms = new();
+        stream.CopyTo(ms);
+
+        return UploadUgcTrackAsync(storage, uploadLink, ms.ToArray());
+    }
+
+    /// <summary>
+    /// Загрузка трека из массива
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="uploadLink">Ссылка на балансировщик для загрузки, можно получить из GetUgcUploadLinkAsync</param>
+    /// <param name="file">Загружаемый трек в виде массив байтов</param>
+    public Task<YResponse<string>> UploadUgcTrackAsync(AuthStorage storage, string uploadLink, byte[] file)
+    {
+        return new YUgcUploadBuilder(api, storage)
+            .Build((uploadLink, file))
+            .GetResponseAsync();
+    }
+}

YandexMusic.API/API/YUgcAPIAsync.cs

@@ -1,72 +0,0 @@
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Models.Playlist;
-using YandexMusic.API.Models.Ugc;
-using YandexMusic.API.Requests.Ugc;
-
-namespace YandexMusic.API
-{
-    public partial class YUgcAPI : YCommonAPI
-    {
-        public YUgcAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        /// <summary>
-        /// Получение ссылки на загрузчик трека
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="playlist">Плейлист, куда будет загружен трек</param>
-        /// <param name="fileName">Название файла для загрузки</param>
-        public Task<YUgcUpload> GetUgcUploadLinkAsync(AuthStorage storage, YPlaylist playlist, string fileName)
-        {
-            return new YUgcGetUploadLinkBuilder(api, storage)
-                .Build((playlist, fileName))
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Загрузка трека из файла
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="uploadLink">Ссылка на балансировщик для загрузки, можно получить из GetUgcUploadLinkAsync</param>
-        /// <param name="filePath">Загружаемый файл</param>
-        public Task<YResponse<string>> UploadUgcTrackAsync(AuthStorage storage, string uploadLink, string filePath)
-        {
-            if (!File.Exists(filePath))
-                throw new FileNotFoundException("Файл для загрузки не существует.", filePath);
-
-            return UploadUgcTrackAsync(storage, uploadLink, File.Open(filePath, FileMode.Open));
-        }
-
-        /// <summary>
-        /// Загрузка трека из потока
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="uploadLink">Ссылка на балансировщик для загрузки, можно получить из GetUgcUploadLinkAsync</param>
-        /// <param name="stream">Поток с данными для загрузки</param>
-        public Task<YResponse<string>> UploadUgcTrackAsync(AuthStorage storage, string uploadLink, Stream stream)
-        {
-            if (stream == null)
-                throw new NullReferenceException("Пустая ссылка на поток загрузки.");
-
-            using MemoryStream ms = new();
-            stream.CopyTo(ms);
-
-            return UploadUgcTrackAsync(storage, uploadLink, ms.ToArray());
-        }
-
-        /// <summary>
-        /// Загрузка трека из массива
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="uploadLink">Ссылка на балансировщик для загрузки, можно получить из GetUgcUploadLinkAsync</param>
-        /// <param name="file">Загружаемый трек в виде массив байтов</param>
-        public Task<YResponse<string>> UploadUgcTrackAsync(AuthStorage storage, string uploadLink, byte[] file)
-        {
-            return new YUgcUploadBuilder(api, storage)
-                .Build((uploadLink, file))
-                .GetResponseAsync();
-        }
-    }
-}

YandexMusic.API/API/YUserAPI.cs

@@ -0,0 +1,300 @@
+using System.Security.Authentication;
+using System.Text.RegularExpressions;
+
+using YandexMusic.API.Common;
+using YandexMusic.API.Models.Account;
+using YandexMusic.API.Models.Common;
+using YandexMusic.API.Requests.Account;
+
+namespace YandexMusic.API;
+
+/// <summary>
+/// API для пользователя
+/// </summary>
+public partial class YUserAPI : YCommonAPI
+{
+    #region Вспомогательные функции
+
+    private async Task<bool> GetCsrfTokenAsync(AuthStorage storage)
+    {
+        using HttpResponseMessage authMethodsResponse = await new YGetAuthMethodsBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+
+        if (!authMethodsResponse.IsSuccessStatusCode)
+            throw new HttpRequestException("Невозможно получить CFRF-токен.");
+
+        string responseString = await authMethodsResponse.Content
+            .ReadAsStringAsync();
+        Match match = Regex.Match(responseString, "\"csrf_token\" value=\"([^\"]+)\"");
+
+        if (!match.Success || match.Groups.Count < 2)
+            return false;
+
+        storage.AuthToken = new YAuthToken
+        {
+            CsfrToken = match.Groups[1].Value
+        };
+
+        return true;
+    }
+
+    private async Task<bool> LoginByCookiesAsync(AuthStorage storage)
+    {
+        if (storage.AuthToken == null)
+            throw new AuthenticationException("Невозможно инициализировать сессию входа.");
+
+        YAccessToken accessToken = await new YGetAuthCookiesBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+
+        storage.IsAuthorized = !string.IsNullOrEmpty(accessToken.AccessToken);
+
+        storage.AccessToken = accessToken;
+        storage.Token = accessToken.AccessToken;
+
+        YShortAccountInfo validateTokenResponse = await new YGetShortAccountInifoBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+
+        if (validateTokenResponse.Status != YAuthStatus.Ok)
+            throw new Exception("Вход в аккаунт не выполнен.");
+
+        storage.IsAuthorized = !string.IsNullOrWhiteSpace(validateTokenResponse.Uid);
+
+        return storage.IsAuthorized;
+    }
+
+    #endregion Вспомогательные функции
+
+    public YUserAPI(YandexMusicApi yandex) : base(yandex)
+    {
+    }
+
+    /// <summary>
+    /// Авторизация
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="token">Токен авторизации</param>
+    /// <returns></returns>
+    public async Task AuthorizeAsync(AuthStorage storage, string token)
+    {
+        if (string.IsNullOrEmpty(token))
+            throw new Exception("Задан пустой токен авторизации.");
+
+        storage.Token = token;
+
+        // Пытаемся получить информацию о пользователе
+        YResponse<YAccountResult> authInfo = await GetUserAuthAsync(storage);
+
+        // Если не авторизован, то авторизуем
+        if (string.IsNullOrEmpty(authInfo.Result.Account.Uid))
+            throw new Exception("Пользователь незалогинен.");
+
+        // Флаг авторизации
+        storage.IsAuthorized = true;
+        storage.User = authInfo.Result.Account;
+    }
+
+    /// <summary>
+    /// Получение информации об авторизации
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YResponse<YAccountResult>> GetUserAuthAsync(AuthStorage storage)
+    {
+        return new YGetAuthInfoBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Создание сеанса и получение доступных методов авторизации
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="userName">Имя пользователя</param>
+    /// <returns></returns>
+    public async Task<YAuthTypes> CreateAuthSessionAsync(AuthStorage storage, string userName)
+    {
+        if (!await GetCsrfTokenAsync(storage))
+            throw new Exception("Невозможно инициализировать сессию входа.");
+
+        YAuthTypes types = await new YGetAuthLoginUserBuilder(api, storage)
+            .Build((storage.AuthToken.CsfrToken, userName))
+            .GetResponseAsync();
+
+        storage.AuthToken.TrackId = types.TrackId;
+
+        return types;
+    }
+
+    /// <summary>
+    /// Получение ссылки на QR-код
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public async Task<string> GetAuthQRLinkAsync(AuthStorage storage)
+    {
+        if (!await GetCsrfTokenAsync(storage))
+            throw new Exception("Невозможно инициализировать сессию входа.");
+
+        YAuthQR result = await new YGetAuthQRBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+
+        if (result.Status != YAuthStatus.Ok)
+            return string.Empty;
+
+        storage.AuthToken = new YAuthToken
+        {
+            TrackId = result.TrackId,
+            CsfrToken = result.CsrfToken
+        };
+
+        return $"https://passport.yandex.ru/auth/magic/code/?track_id={result.TrackId}";
+    }
+
+    /// <summary>
+    /// Авторизация по QR-коду
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public async Task<YAuthQRStatus> AuthorizeByQRAsync(AuthStorage storage)
+    {
+        if (storage.AuthToken == null)
+            throw new Exception("Не выполнен запрос на авторизацию по QR.");
+
+        try
+        {
+            YAuthQRStatus qrStatus = await new YGetAuthLoginQRBuilder(api, storage)
+                .Build(null)
+                .GetResponseAsync();
+            if (qrStatus.Status != YAuthStatus.Ok)
+                return qrStatus;
+
+            bool ok = await LoginByCookiesAsync(storage);
+            if (!ok)
+                throw new AuthenticationException("Ошибка авторизации по QR.");
+
+            return qrStatus;
+        }
+        catch (Exception ex)
+        {
+            throw new AuthenticationException("Ошибка авторизации по QR.", ex);
+        }
+    }
+
+    /// <summary>
+    /// Получение <see cref="YAuthCaptcha"/>
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YAuthCaptcha> GetCaptchaAsync(AuthStorage storage)
+    {
+        if (storage.AuthToken == null || string.IsNullOrWhiteSpace(storage.AuthToken.CsfrToken))
+            throw new AuthenticationException($"Не найдена сессия входа. Выполните {nameof(CreateAuthSessionAsync)} перед использованием.");
+
+        return new YGetAuthCaptchaBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Авторизация по captcha
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="captchaValue">Значение captcha</param>
+    /// <returns></returns>
+    public Task<YAuthBase> AuthorizeByCaptchaAsync(AuthStorage storage, string captchaValue)
+    {
+        if (storage.AuthToken == null || string.IsNullOrWhiteSpace(storage.AuthToken.CsfrToken))
+            throw new AuthenticationException($"Не найдена сессия входа. Выполните {nameof(CreateAuthSessionAsync)} перед использованием.");
+
+        return new YGetAuthLoginCaptchaBuilder(api, storage)
+            .Build(captchaValue)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Получение письма авторизации на почту пользователя
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public Task<YAuthLetter> GetAuthLetterAsync(AuthStorage storage)
+    {
+        return new YGetAuthLetterBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+    }
+
+    /// <summary>
+    /// Авторизация после подтверждения входа через письмо
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <returns></returns>
+    public async Task<bool> AuthorizeByLetterAsync(AuthStorage storage)
+    {
+        YAuthLetterStatus status = await new YGetAuthLoginLetterBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+
+        if (status.Status == YAuthStatus.Ok && !status.MagicLinkConfirmed)
+            throw new Exception("Не подтвержден вход посредством e-mail.");
+
+        return await LoginByCookiesAsync(storage);
+    }
+
+    /// <summary>
+    /// Авторизация с помощью пароля из приложения Яндекс
+    /// </summary>
+    /// <param name="storage">Хранилище</param>
+    /// <param name="password">Пароль</param>
+    /// <returns></returns>
+    public async Task<YAuthBase> AuthorizeByAppPasswordAsync(AuthStorage storage, string password)
+    {
+        if (storage.AuthToken == null || string.IsNullOrWhiteSpace(storage.AuthToken.CsfrToken))
+            throw new AuthenticationException($"Не найдена сессия входа. Выполните {nameof(CreateAuthSessionAsync)} перед использованием.");
+
+        YAuthBase response = await new YGetAuthAppPasswordBuilder(api, storage)
+            .Build(password)
+            .GetResponseAsync();
+
+        if (response.Status == YAuthStatus.Ok)
+        {
+            bool ok = await LoginByCookiesAsync(storage);
+            if (!ok)
+                throw new AuthenticationException("Ошибка авторизации.");
+        }
+
+        return response;
+    }
+
+    /// <summary>
+    /// Получение <see cref="YAccessToken"/> после авторизации с помощью QR, e-mail, пароля из приложения
+    /// </summary>
+    public async Task<YAccessToken> GetAccessTokenAsync(AuthStorage storage)
+    {
+        if (storage.AuthToken == null)
+            throw new Exception("Не найдена сессия входа.");
+
+        YAccessToken accessToken = await new YGetMusicTokenBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+
+        storage.Token = accessToken.AccessToken;
+
+        return accessToken;
+    }
+
+    /// <summary>
+    /// Получение информации о пользователе через логин Яндекса
+    /// </summary>
+    public Task<YLoginInfo> GetLoginInfoAsync(AuthStorage storage)
+    {
+        return new YGetLoginInfoBuilder(api, storage)
+            .Build(null)
+            .GetResponseAsync();
+    }
+
+
+}

YandexMusic.API/API/YUserAPIAsync.cs

@@ -1,303 +0,0 @@
-using System.Security.Authentication;
-using System.Text.RegularExpressions;
-
-using YandexMusic.API.Common;
-using YandexMusic.API.Models.Account;
-using YandexMusic.API.Models.Common;
-using YandexMusic.API.Requests.Account;
-
-namespace YandexMusic.API
-{
-    /// <summary>
-    /// API для пользователя
-    /// </summary>
-    public partial class YUserAPI : YCommonAPI
-    {
-        #region Вспомогательные функции
-
-        private async Task<bool> GetCsrfTokenAsync(AuthStorage storage)
-        {
-            using HttpResponseMessage authMethodsResponse = await new YGetAuthMethodsBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-
-            if (!authMethodsResponse.IsSuccessStatusCode)
-                throw new HttpRequestException("Невозможно получить CFRF-токен.");
-
-            string responseString = await authMethodsResponse.Content
-                .ReadAsStringAsync();
-            Match match = Regex.Match(responseString, "\"csrf_token\" value=\"([^\"]+)\"");
-
-            if (!match.Success || match.Groups.Count < 2)
-                return false;
-
-            storage.AuthToken = new YAuthToken
-            {
-                CsfrToken = match.Groups[1].Value
-            };
-
-            return true;
-        }
-
-        private async Task<bool> LoginByCookiesAsync(AuthStorage storage)
-        {
-            if (storage.AuthToken == null)
-                throw new AuthenticationException("Невозможно инициализировать сессию входа.");
-
-            YAccessToken accessToken = await new YGetAuthCookiesBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-
-            storage.IsAuthorized = !string.IsNullOrEmpty(accessToken.AccessToken);
-
-            storage.AccessToken = accessToken;
-            storage.Token = accessToken.AccessToken;
-
-            YShortAccountInfo validateTokenResponse = await new YGetShortAccountInifoBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-
-            if (validateTokenResponse.Status != YAuthStatus.Ok)
-                throw new Exception("Вход в аккаунт не выполнен.");
-
-            storage.IsAuthorized = !string.IsNullOrWhiteSpace(validateTokenResponse.Uid);
-
-            return storage.IsAuthorized;
-        }
-
-        #endregion Вспомогательные функции
-
-
-
-        public YUserAPI(YandexMusicApi yandex) : base(yandex)
-        {
-        }
-
-        /// <summary>
-        /// Авторизация
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="token">Токен авторизации</param>
-        /// <returns></returns>
-        public async Task AuthorizeAsync(AuthStorage storage, string token)
-        {
-            if (string.IsNullOrEmpty(token))
-                throw new Exception("Задан пустой токен авторизации.");
-
-            storage.Token = token;
-
-            // Пытаемся получить информацию о пользователе
-            YResponse<YAccountResult> authInfo = await GetUserAuthAsync(storage);
-
-            // Если не авторизован, то авторизуем
-            if (string.IsNullOrEmpty(authInfo.Result.Account.Uid))
-                throw new Exception("Пользователь незалогинен.");
-
-            // Флаг авторизации
-            storage.IsAuthorized = true;
-            storage.User = authInfo.Result.Account;
-        }
-
-        /// <summary>
-        /// Получение информации об авторизации
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YResponse<YAccountResult>> GetUserAuthAsync(AuthStorage storage)
-        {
-            return new YGetAuthInfoBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Создание сеанса и получение доступных методов авторизации
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="userName">Имя пользователя</param>
-        /// <returns></returns>
-        public async Task<YAuthTypes> CreateAuthSessionAsync(AuthStorage storage, string userName)
-        {
-            if (!await GetCsrfTokenAsync(storage))
-                throw new Exception("Невозможно инициализировать сессию входа.");
-
-            YAuthTypes types = await new YGetAuthLoginUserBuilder(api, storage)
-                .Build((storage.AuthToken.CsfrToken, userName))
-                .GetResponseAsync();
-
-            storage.AuthToken.TrackId = types.TrackId;
-
-            return types;
-        }
-
-        /// <summary>
-        /// Получение ссылки на QR-код
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public async Task<string> GetAuthQRLinkAsync(AuthStorage storage)
-        {
-            if (!await GetCsrfTokenAsync(storage))
-                throw new Exception("Невозможно инициализировать сессию входа.");
-
-            YAuthQR result = await new YGetAuthQRBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-
-            if (result.Status != YAuthStatus.Ok)
-                return string.Empty;
-
-            storage.AuthToken = new YAuthToken
-            {
-                TrackId = result.TrackId,
-                CsfrToken = result.CsrfToken
-            };
-
-            return $"https://passport.yandex.ru/auth/magic/code/?track_id={result.TrackId}";
-        }
-
-        /// <summary>
-        /// Авторизация по QR-коду
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public async Task<YAuthQRStatus> AuthorizeByQRAsync(AuthStorage storage)
-        {
-            if (storage.AuthToken == null)
-                throw new Exception("Не выполнен запрос на авторизацию по QR.");
-
-            try
-            {
-                YAuthQRStatus qrStatus = await new YGetAuthLoginQRBuilder(api, storage)
-                    .Build(null)
-                    .GetResponseAsync();
-                if (qrStatus.Status != YAuthStatus.Ok)
-                    return qrStatus;
-
-                bool ok = await LoginByCookiesAsync(storage);
-                if (!ok)
-                    throw new AuthenticationException("Ошибка авторизации по QR.");
-
-                return qrStatus;
-            }
-            catch (Exception ex)
-            {
-                throw new AuthenticationException("Ошибка авторизации по QR.", ex);
-            }
-        }
-
-        /// <summary>
-        /// Получение <see cref="YAuthCaptcha"/>
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YAuthCaptcha> GetCaptchaAsync(AuthStorage storage)
-        {
-            if (storage.AuthToken == null || string.IsNullOrWhiteSpace(storage.AuthToken.CsfrToken))
-                throw new AuthenticationException($"Не найдена сессия входа. Выполните {nameof(CreateAuthSessionAsync)} перед использованием.");
-
-            return new YGetAuthCaptchaBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Авторизация по captcha
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="captchaValue">Значение captcha</param>
-        /// <returns></returns>
-        public Task<YAuthBase> AuthorizeByCaptchaAsync(AuthStorage storage, string captchaValue)
-        {
-            if (storage.AuthToken == null || string.IsNullOrWhiteSpace(storage.AuthToken.CsfrToken))
-                throw new AuthenticationException($"Не найдена сессия входа. Выполните {nameof(CreateAuthSessionAsync)} перед использованием.");
-
-            return new YGetAuthLoginCaptchaBuilder(api, storage)
-                .Build(captchaValue)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Получение письма авторизации на почту пользователя
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public Task<YAuthLetter> GetAuthLetterAsync(AuthStorage storage)
-        {
-            return new YGetAuthLetterBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-        }
-
-        /// <summary>
-        /// Авторизация после подтверждения входа через письмо
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <returns></returns>
-        public async Task<bool> AuthorizeByLetterAsync(AuthStorage storage)
-        {
-            YAuthLetterStatus status = await new YGetAuthLoginLetterBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-
-            if (status.Status == YAuthStatus.Ok && !status.MagicLinkConfirmed)
-                throw new Exception("Не подтвержден вход посредством e-mail.");
-
-            return await LoginByCookiesAsync(storage);
-        }
-
-        /// <summary>
-        /// Авторизация с помощью пароля из приложения Яндекс
-        /// </summary>
-        /// <param name="storage">Хранилище</param>
-        /// <param name="password">Пароль</param>
-        /// <returns></returns>
-        public async Task<YAuthBase> AuthorizeByAppPasswordAsync(AuthStorage storage, string password)
-        {
-            if (storage.AuthToken == null || string.IsNullOrWhiteSpace(storage.AuthToken.CsfrToken))
-                throw new AuthenticationException($"Не найдена сессия входа. Выполните {nameof(CreateAuthSessionAsync)} перед использованием.");
-
-            YAuthBase response = await new YGetAuthAppPasswordBuilder(api, storage)
-                .Build(password)
-                .GetResponseAsync();
-
-            if (response.Status == YAuthStatus.Ok)
-            {
-                bool ok = await LoginByCookiesAsync(storage);
-                if (!ok)
-                    throw new AuthenticationException("Ошибка авторизации.");
-            }
-
-            return response;
-        }
-
-        /// <summary>
-        /// Получение <see cref="YAccessToken"/> после авторизации с помощью QR, e-mail, пароля из приложения
-        /// </summary>
-        public async Task<YAccessToken> GetAccessTokenAsync(AuthStorage storage)
-        {
-            if (storage.AuthToken == null)
-                throw new Exception("Не найдена сессия входа.");
-
-            YAccessToken accessToken = await new YGetMusicTokenBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-
-            storage.Token = accessToken.AccessToken;
-
-            return accessToken;
-        }
-
-        /// <summary>
-        /// Получение информации о пользователе через логин Яндекса
-        /// </summary>
-        public Task<YLoginInfo> GetLoginInfoAsync(AuthStorage storage)
-        {
-            return new YGetLoginInfoBuilder(api, storage)
-                .Build(null)
-                .GetResponseAsync();
-        }
-
-
-    }
-}

YandexMusic.API/API/YYnisonAPI.cs

@@ -0,0 +1,21 @@
+using YandexMusic.API.Common;
+using YandexMusic.API.Common.Ynison;
+
+namespace YandexMusic.API;
+/// <summary>
+/// API Ynison
+/// </summary>
+public partial class YYnisonAPI : YCommonAPI
+{
+    public YYnisonAPI(YandexMusicApi yandex) : base(yandex)
+    {
+    }
+
+    public YnisonPlayer GetPlayer(AuthStorage storage)
+    {
+        if (string.IsNullOrEmpty(storage.Token))
+            throw new Exception("Токен пользователя не задан.");
+
+        return new(api, storage);
+    }
+}

YandexMusic.API/Common/AuthStorage.cs

@@ -1,26 +1,20 @@
 using System.Net;
-
-using YandexMusic.API.Common.Debug;
 using YandexMusic.API.Common.Providers;
 using YandexMusic.API.Models.Account;
 using YandexMusic.API.Requests.Common;
 
-namespace YandexMusic.API.Common
-{
+namespace YandexMusic.API.Common;
+
 /// <summary>
 /// Хранилище данных пользователя
 /// </summary>
 public class AuthStorage
 {
-        #region Свойства
-
     /// <summary>
     /// Http-контекст
     /// </summary>
     public HttpContext Context { get; }
 
-        public DebugSettings Debug { get; set; }
-
     /// <summary>
     /// Флаг авторизации
     /// </summary>
@@ -53,40 +47,14 @@ namespace YandexMusic.API.Common
 
     internal YAuthToken AuthToken { get; set; }
 
-        #endregion Свойства
-
-
-
     /// <summary>
     /// Конструктор
     /// </summary>
-        public AuthStorage(DebugSettings settings = null)
+    public AuthStorage(IRequestProvider provider)
     {
         User = new YAccount();
         Context = new HttpContext();
-            Debug = settings;
-            Provider = new DefaultRequestProvider(this);
-
-            if (Debug is { ClearDirectory: true })
-            {
-                Debug.Clear();
-            }
-        }
-
-        /// <summary>
-        /// Конструктор
-        /// </summary>
-        public AuthStorage(IRequestProvider provider, DebugSettings settings = null)
-        {
-            User = new YAccount();
-            Context = new HttpContext();
-            Debug = settings;
         Provider = provider;
-
-            if (Debug is { ClearDirectory: true })
-            {
-                Debug.Clear();
-            }
     }
 
     /// <summary>
@@ -100,4 +68,3 @@ namespace YandexMusic.API.Common
 
 
 }
-}

YandexMusic.API/Common/DataDownloader.cs

@@ -1,7 +1,7 @@
 using System.Net;
 
-namespace YandexMusic.API.Common
-{
+namespace YandexMusic.API.Common;
+
 /// <summary>
 /// Загрузчик файлов по ссылке
 /// </summary>
@@ -41,4 +41,3 @@ namespace YandexMusic.API.Common
         authStorage = storage;
     }
 }
-}

YandexMusic.API/Common/Encryptor.cs

@@ -1,15 +1,13 @@
 using System.Security.Cryptography;
 using System.Text;
 
-namespace YandexMusic.API.Common
-{
+namespace YandexMusic.API.Common;
+
 /// <summary>
 /// Класс для шифровки
 /// </summary>
 public class Encryptor
 {
-        #region Поля
-
     private readonly string IV = "encryption";
     private readonly byte[] IVHash;
 
@@ -18,20 +16,11 @@ namespace YandexMusic.API.Common
     private readonly MD5 md5;
     private readonly Aes aesAlg;
 
-
-        #endregion Поля
-
-        #region Вспомогательные функции
-
     private byte[] GetHash(string value)
     {
         return md5.ComputeHash(Encoding.UTF8.GetBytes(value));
     }
 
-        #endregion Вспомогательные функции
-
-
-
     public Encryptor(string key)
     {
         md5 = MD5.Create();
@@ -72,4 +61,3 @@ namespace YandexMusic.API.Common
 
 
 }
-}

YandexMusic.API/Common/Providers/CommonRequestProvider.cs

@@ -1,60 +1,56 @@
-using YandexMusic.API.Models.Common;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using YandexMusic.API.Models.Common;
 
-namespace YandexMusic.API.Common.Providers
+namespace YandexMusic.API.Common.Providers;
+
+/// <summary>Базовый провайдер HTTP-запросов с общей логикой десериализации.</summary>
+public abstract class CommonRequestProvider : IRequestProvider
 {
-    public class CommonRequestProvider : IRequestProvider
+    /// <summary>Хранилище данных авторизации.</summary>
+    protected readonly AuthStorage storage;
+
+    /// <summary>Настройки сериализации JSON (регистронезависимые, поддержка enum-строк).</summary>
+    private static readonly JsonSerializerOptions JsonOptions = new()
     {
-        #region Поля
+        PropertyNameCaseInsensitive = true,
+        Converters = { new JsonStringEnumConverter(JsonNamingPolicy.CamelCase) }
+    };
 
-        protected AuthStorage storage;
-
-        #endregion Поля
-
-
-
-        public CommonRequestProvider(AuthStorage authStorage)
+    /// <summary>Инициализирует новый экземпляр провайдера.</summary>
+    /// <param name="authStorage">Хранилище авторизации.</param>
+    protected CommonRequestProvider(AuthStorage authStorage)
     {
         storage = authStorage;
     }
 
+    /// <summary>Выполняет HTTP-запрос и возвращает ответ.</summary>
+    public abstract Task<HttpResponseMessage> GetWebResponseAsync(
+        HttpRequestMessage message,
+        HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead);
 
-
-        #region IRequestProvider
-
-        public virtual Task<HttpResponseMessage> GetWebResponseAsync(HttpRequestMessage message, HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead)
+    /// <summary>Преобразует HTTP-ответ в объект типа T.</summary>
+    public virtual async Task<T> GetDataFromResponseAsync<T>(
+        YandexMusicApi api,
+        HttpResponseMessage response)
     {
-            throw new NotImplementedException();
-        }
-
-        public virtual async Task<T> GetDataFromResponseAsync<T>(YandexMusicApi api, HttpResponseMessage response)
-        {
-            string result = await response.Content.ReadAsStringAsync();
+        var json = await response.Content.ReadAsStringAsync();
 
         if (!response.IsSuccessStatusCode)
         {
-                YErrorResponse exception = JsonConvert.DeserializeObject<YErrorResponse>(result);
-                throw exception ?? new Exception("Ошибка десериализации ответа с ошибкой.");
+            var error = JsonSerializer.Deserialize<YErrorResponse>(json, JsonOptions);
+            throw error ?? new Exception("Ошибка десериализации ответа с ошибкой.");
         }
 
         try
         {
-                JsonSerializerSettings settings = new()
-                {
-                    Converters = new List<JsonConverter> {
-                        new YExecutionContextConverter(api, storage)
-                    }
-                };
-
-                return storage.Debug != null
-                    ? storage.Debug.Deserialize<T>(response.RequestMessage?.RequestUri?.AbsolutePath, result, settings)
-                    : JsonConvert.DeserializeObject<T>(result, settings);
+            // Если нужен контекст выполнения, он добавляется через кастомный конвертер
+            return JsonSerializer.Deserialize<T>(json, JsonOptions)
+                ?? throw new JsonException("Десериализация вернула null");
         }
         catch (Exception ex)
         {
-                throw new Exception($"Ошибка десериализации {ex}");
+            throw new Exception($"Ошибка десериализации: {ex.Message}", ex);
         }
     }
-
-        #endregion IRequestProvider
-    }
 }

YandexMusic.API/Common/Providers/DefaultRequestProvider.cs

@@ -1,69 +1,45 @@
 using System.Net;
 
-using YandexMusic.API.Models.Common;
+namespace YandexMusic.API.Common.Providers;
 
-namespace YandexMusic.API.Common.Providers
-{
-    /// <summary>
-    /// Стандартный провайдер запросов
-    /// </summary>
+/// <summary>Стандартный провайдер HTTP-запросов с использованием HttpClient.</summary>
 public class DefaultRequestProvider : CommonRequestProvider
 {
-        #region Вспомогательные функции
+    /// <summary>Инициализирует новый экземпляр провайдера.</summary>
+    /// <param name="authStorage">Хранилище авторизации.</param>
+    public DefaultRequestProvider(AuthStorage authStorage) : base(authStorage) { }
 
-        private Exception ProcessException(Exception ex)
-        {
-            if (ex is not WebException webException)
-                return ex;
-
-            if (webException.Response is null)
-                return ex;
-
-            Stream s = webException.Response.GetResponseStream();
-            if (s is null)
-                return ex;
-
-            using StreamReader sr = new(s);
-            string result = sr.ReadToEnd();
-
-            YErrorResponse exception = JsonConvert.DeserializeObject<YErrorResponse>(result);
-
-            return exception ?? ex;
-        }
-
-        #endregion Вспомогательные функции
-
-
-
-        public DefaultRequestProvider(AuthStorage authStorage) : base(authStorage)
-        {
-        }
-
-
-
-        #region IRequestProvider
-
-        public override Task<HttpResponseMessage> GetWebResponseAsync(HttpRequestMessage message,
+    /// <summary>Выполняет HTTP-запрос и возвращает ответ.</summary>
+    /// <param name="message">HTTP-запрос.</param>
+    /// <param name="completionOption">Опция завершения запроса.</param>
+    /// <returns>HTTP-ответ.</returns>
+    public override async Task<HttpResponseMessage> GetWebResponseAsync(
+        HttpRequestMessage message,
         HttpCompletionOption completionOption = HttpCompletionOption.ResponseContentRead)
     {
-            try
-            {
-                HttpClient client = new(new SocketsHttpHandler
+        using var handler = new SocketsHttpHandler
         {
             Proxy = storage.Context.WebProxy,
-                    AutomaticDecompression = DecompressionMethods.GZip,
+            AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,
             UseCookies = true,
             CookieContainer = storage.Context.Cookies,
-                });
+            AllowAutoRedirect = true,
+            MaxAutomaticRedirections = 10
+        };
 
-                return client.SendAsync(message, completionOption);
-            }
-            catch (Exception ex)
+        using var client = new HttpClient(handler);
+
+        try
         {
-                throw ProcessException(ex);
-            }
+            return await client.SendAsync(message, completionOption);
         }
+        catch (HttpRequestException ex)
+        {
+            // Пытаемся извлечь тело ошибки, если оно доступно
+            if (ex.InnerException == null)
+                throw;
 
-        #endregion IRequestProvider
+            throw new Exception($"Ошибка HTTP-запроса: {ex.Message}", ex);
+        }
     }
 }

YandexMusic.API/Common/Providers/MockRequestProvider.cs

@@ -9,7 +9,6 @@
 
         public MockRequestProvider(AuthStorage authStorage) : base(authStorage)
         {
-            storage = authStorage;
         }
 
 

YandexMusic.API/Common/Ynison/UpperSnakeCaseNamingPolicy.cs

@@ -0,0 +1,43 @@
+using System.Text;
+using System.Text.Json;
+
+namespace YandexMusic.API.Common.Ynison;
+
+/// <summary>Политика именования в формате UPPER_SNAKE_CASE (все буквы верхнего регистра, слова через подчёркивание).</summary>
+public class UpperSnakeCaseNamingPolicy : SnakeCaseNamingPolicy
+{
+    /// <summary>Преобразует имя свойства в формат UPPER_SNAKE_CASE.</summary>
+    public override string ConvertName(string name)
+    {
+        var snakeCase = base.ConvertName(name);
+        return snakeCase.ToUpperInvariant();
+    }
+}
+
+/// <summary>Базовая политика именования в формате snake_case (все буквы нижнего регистра, слова через подчёркивание).</summary>
+public class SnakeCaseNamingPolicy : JsonNamingPolicy
+{
+    /// <summary>Преобразует имя свойства в формат snake_case.</summary>
+    public override string ConvertName(string name)
+    {
+        if (string.IsNullOrEmpty(name))
+            return name;
+
+        var sb = new StringBuilder();
+        for (int i = 0; i < name.Length; i++)
+        {
+            char c = name[i];
+            if (char.IsUpper(c))
+            {
+                if (i > 0)
+                    sb.Append('_');
+                sb.Append(char.ToLowerInvariant(c));
+            }
+            else
+            {
+                sb.Append(c);
+            }
+        }
+        return sb.ToString();
+    }
+}

YandexMusic.API/Common/Ynison/UpperSnakeCaseNamingStrategy.cs

@@ -1,7 +0,0 @@
-namespace YandexMusic.API.Common.Ynison
-{
-    public class UpperSnakeCaseNamingStrategy : SnakeCaseNamingStrategy
-    {
-        protected override string ResolvePropertyName(string name) => base.ResolvePropertyName(name).ToUpper();
-    }
-}

YandexMusic.API/Common/Ynison/YnisonPlayer.cs

@@ -1,131 +1,101 @@
 using System.Net.WebSockets;
+using System.Text.Json;
+using System.Text.Json.Serialization;
 using YandexMusic.API.Models.Track;
 using YandexMusic.API.Models.Ynison;
 using YandexMusic.API.Models.Ynison.Messages;
 
-namespace YandexMusic.API.Common.Ynison
-{
+namespace YandexMusic.API.Common.Ynison;
+
+/// <summary>Плеер для управления воспроизведением через протокол Ynison (WebSocket).</summary>
 public class YnisonPlayer : IDisposable
 {
-        #region Поля
+    private readonly JsonSerializerOptions _jsonOptions;
+    private readonly AuthStorage _storage;
+    private YnisonWebSocket? _redirector;
+    private YnisonWebSocket? _state;
 
-        private readonly JsonSerializerSettings jsonSettings = new()
-        {
-            Converters = new List<JsonConverter> {
-                new StringEnumConverter(new UpperSnakeCaseNamingStrategy())
-            },
+    /// <summary>API Яндекс Музыки.</summary>
+    public YandexMusicApi API { get; }
 
-            NullValueHandling = NullValueHandling.Ignore,
-            ContractResolver = new DefaultContractResolver
+    /// <summary>Текущее состояние плеера.</summary>
+    public YYnisonState? State { get; private set; }
+
+    /// <summary>Текущий проигрываемый трек.</summary>
+    public YTrack? Current => GetCurrentAsync().GetAwaiter().GetResult();
+
+    /// <summary>Событие получения нового состояния.</summary>
+    public event EventHandler<ReceiveEventArgs>? OnReceive;
+
+    /// <summary>Событие закрытия соединения.</summary>
+    public event EventHandler<CloseEventArgs>? OnClose;
+
+    /// <summary>Аргументы события получения состояния.</summary>
+    public class ReceiveEventArgs : EventArgs
     {
-                // Важно! Унисон отдаёт данные в SnakeCase
-                NamingStrategy = new SnakeCaseNamingStrategy()
+        /// <summary>Состояние плеера.</summary>
+        public YYnisonState State { get; init; } = null!;
     }
+
+    /// <summary>Аргументы события закрытия соединения.</summary>
+    public class CloseEventArgs : EventArgs
+    {
+        /// <summary>Статус закрытия.</summary>
+        public WebSocketCloseStatus? Status { get; init; }
+        /// <summary>Описание причины закрытия.</summary>
+        public string? Description { get; init; }
+    }
+
+    internal YnisonPlayer(YandexMusicApi api, AuthStorage authStorage)
+    {
+        API = api;
+        _storage = authStorage;
+        _jsonOptions = new JsonSerializerOptions
+        {
+            PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
+            DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+            Converters = { new JsonStringEnumConverter(new UpperSnakeCaseNamingPolicy(), false) }
         };
-
-        private AuthStorage storage;
-        private YnisonWebSocket redirector;
-        private YnisonWebSocket state;
-
-        #endregion Поля
-
-        #region Свойства
-
-        /// <summary>
-        /// API
-        /// </summary>
-        public YandexMusicApi API { get; internal set; }
-
-        /// <summary>
-        /// Состояние
-        /// </summary>
-        public YYnisonState State { get; internal set; }
-
-        /// <summary>
-        /// Текущий проигрываемый трек
-        /// </summary>
-        public YTrack Current => GetCurrent();
-
-        #endregion Свойства
-
-        #region События
-
-        public class ReceiveEventArgs
-        {
-            public YYnisonState State { get; internal set; }
+        _redirector = new YnisonWebSocket();
+        _state = new YnisonWebSocket();
     }
 
-        public delegate void OnReceiveEventHandler(YnisonPlayer player, ReceiveEventArgs args);
-
-        /// <summary>
-        /// Получение данных
-        /// </summary>
-        public event OnReceiveEventHandler OnReceive;
-
-
-        public class CloseEventArgs
-        {
-            public WebSocketCloseStatus? Status { get; set; }
-            public string Description { get; set; }
-        }
-
-        public delegate void OnCloseEventHandler(YnisonPlayer player, CloseEventArgs args);
-
-        /// <summary>
-        /// Получение данных
-        /// </summary>
-        public event OnCloseEventHandler OnClose;
-
-        #endregion События
-
-        #region Вспомогательные функции
-
-        private string SerializeJson(object data)
-        {
-            return JsonConvert.SerializeObject(data, jsonSettings);
-        }
+    private string SerializeJson(object data) => JsonSerializer.Serialize(data, _jsonOptions);
 
     private T Deserialize<T>(YYnisonMessageType messageType, string data)
     {
-            return storage.Debug != null
-                ? storage.Debug.Deserialize<T>($"Ynison{messageType}", data, jsonSettings)
-                : JsonConvert.DeserializeObject<T>(data, jsonSettings);
+        return JsonSerializer.Deserialize<T>(data, _jsonOptions)
+            ?? throw new JsonException("Десериализация вернула null");
     }
 
     private T DeserializeMessage<T>(YYnisonMessageType messageType, string data)
     {
-            JObject o = JObject.Parse(data);
-            // Сообщение с ошибкой
-            if (o.ContainsKey("error"))
+        using var doc = JsonDocument.Parse(data);
+        if (doc.RootElement.TryGetProperty("error", out _))
         {
-                YYnisonErrorMessage exception = Deserialize<YYnisonErrorMessage>(YYnisonMessageType.Error, data);
-                throw exception ?? new Exception("Ошибка десериализации ответа с ошибкой.");
+            var error = Deserialize<YYnisonErrorMessage>(YYnisonMessageType.Error, data);
+            throw error ?? new Exception("Ошибка десериализации ответа с ошибкой.");
         }
-
         return Deserialize<T>(messageType, data);
     }
 
     private string DefaultState()
     {
-            YYnisonVersion version = new()
+        var version = new YYnisonVersion
         {
-                DeviceId = storage.DeviceId,
+            DeviceId = _storage.DeviceId,
             Version = "0"
         };
-
-            YYnisonUpdateFullStateMessage fullState = new()
+        var fullState = new YYnisonUpdateFullStateMessage
         {
-                UpdateFullState = new()
+            UpdateFullState = new YYnisonFullState
             {
-                    Device = new()
+                Device = new YYnisonDevice
                 {
-                        Capabilities = new()
+                    Capabilities = new YYnisonDeviceCapabilities { CanBePlayer = true },
+                    Info = new YYnisonDeviceInfo
                     {
-                            CanBePlayer = true
-                        },
-                        Info = new()
-                        {
-                            DeviceId = storage.DeviceId,
+                        DeviceId = _storage.DeviceId,
                         AppName = "Yandex Music API",
                         AppVersion = "0.0.1",
                         Type = "WEB",
@@ -133,183 +103,81 @@ namespace YandexMusic.API.Common.Ynison
                     },
                     IsShadow = true
                 },
-                    PlayerState = new()
+                PlayerState = new YYnisonPlayerState
                 {
-                        PlayerQueue = new()
-                        {
-                            Version = version
-                        },
-                        Status = new()
-                        {
-                            Version = version
-                        }
+                    PlayerQueue = new YYnisonPlayerQueue { Version = version },
+                    Status = new YYnisonPlayerStateStatus { Version = version }
                 }
             }
         };
-
         return SerializeJson(fullState);
     }
 
-        private YTrack GetCurrent()
+    private async Task<YTrack?> GetCurrentAsync()
     {
-            if (State == null)
-                return null;
-
+        if (State == null) return null;
         int index = State.PlayerState.PlayerQueue.CurrentPlayableIndex;
-            if (index < 0 || index > State.PlayerState.PlayerQueue.PlayableList.Count)
+        if (index < 0 || index >= State.PlayerState.PlayerQueue.PlayableList.Count)
             return null;
-
-            YYnisonPlayableItem item = State.PlayerState.PlayerQueue.PlayableList[index];
-
-            return API.Track.Get(storage, item.PlayableId)
-                .Result
-                .FirstOrDefault();
+        var item = State.PlayerState.PlayerQueue.PlayableList[index];
+        var response = await API.Track.GetAsync(_storage, item.PlayableId);
+        return response?.Result?.FirstOrDefault();
     }
 
-        private void UpdateState()
+    private async Task UpdateStateAsync()
     {
-            YYnisonUpdatePlayerStateMessage update = new()
+        if (State == null) return;
+        var update = new YYnisonUpdatePlayerStateMessage
         {
             UpdatePlayerState = State.PlayerState
         };
-
-            update.UpdatePlayerState.Status.Version = new()
-            {
-                DeviceId = storage.DeviceId
-            };
-
-            update.UpdatePlayerState.PlayerQueue.Version = new()
-            {
-                DeviceId = storage.DeviceId
-            };
-
-            try
-            {
-                state.Send(SerializeJson(update));
-            }
-            catch (Exception ex)
-            {
-                Console.WriteLine(ex);
-                throw;
-            }
+        update.UpdatePlayerState.Status.Version = new YYnisonVersion { DeviceId = _storage.DeviceId };
+        update.UpdatePlayerState.PlayerQueue.Version = new YYnisonVersion { DeviceId = _storage.DeviceId };
+        if (_state != null)
+            await _state.SendAsync(SerializeJson(update));
     }
 
-        #endregion Вспомогательные функции
-
-
-
-        #region Подключение
-
-        public void Connect()
+    /// <summary>Подключается к Ynison и начинает получение состояния.</summary>
+    public async Task ConnectAsync()
     {
-            redirector.Connect(storage, "wss://ynison.music.yandex.ru/redirector.YnisonRedirectService/GetRedirectToYnison");
-            redirector.OnReceive += (socket, data) =>
+        if (_redirector == null) throw new ObjectDisposedException(nameof(YnisonPlayer));
+        await _redirector.ConnectAsync(_storage, "wss://ynison.music.yandex.ru/redirector.YnisonRedirectService/GetRedirectToYnison");
+        _redirector.OnReceive += async (socket, data) =>
         {
-                YYnisonRedirect redirectInfo = Deserialize<YYnisonRedirect>(YYnisonMessageType.Redirect, data.Data);
-
-                if (state.IsConnected)
-                    return;
-
-                state.Connect(storage, $"wss://{redirectInfo.Host}/ynison_state.YnisonStateService/PutYnisonState", redirectInfo.RedirectTicket);
-                state.OnReceive += (s, d) =>
+            var redirectInfo = Deserialize<YYnisonRedirect>(YYnisonMessageType.Redirect, data.Data);
+            if (_state == null) return;
+            if (_state.IsConnected) return;
+            await _state.ConnectAsync(_storage, $"wss://{redirectInfo.Host}/ynison_state.YnisonStateService/PutYnisonState", redirectInfo.RedirectTicket);
+            _state.OnReceive += (s, d) =>
             {
-                    YYnisonState message = DeserializeMessage<YYnisonState>(YYnisonMessageType.State, d.Data);
-
+                var message = DeserializeMessage<YYnisonState>(YYnisonMessageType.State, d.Data);
                 State = message;
-
-                    OnReceive?.Invoke(this, new ReceiveEventArgs
-                    {
-                        State = State
-                    });
+                OnReceive?.Invoke(this, new ReceiveEventArgs { State = State });
             };
-
-                state.OnClose += (s, args) =>
+            _state.OnClose += (s, args) =>
             {
-                    OnClose?.Invoke(this, new CloseEventArgs
-                    {
-                        Status = args.Status,
-                        Description = args.Description
-                    });
+                OnClose?.Invoke(this, new CloseEventArgs { Status = args.Status, Description = args.Description });
             };
-
-                state.BeginReceive();
-                // Отправка изначального состояния
-                state.Send(DefaultState());
+            _ = _state.BeginReceiveAsync();
+            await _state.SendAsync(DefaultState());
         };
-
-            redirector.BeginReceive();
+        await _redirector.BeginReceiveAsync();
     }
 
-        public void Disconnect()
+    /// <summary>Отключается от Ynison.</summary>
+    public async Task DisconnectAsync()
     {
-            state?.StopReceive();
-            redirector?.StopReceive();
+        if (_state != null) await _state.StopReceiveAsync();
+        if (_redirector != null) await _redirector.StopReceiveAsync();
     }
 
-        #endregion Подключение
-
-        #region Плеер
-
-        /*
-        public void Play()
-        {
-
-        }
-
-        public void Stop()
-        {
-
-        }
-
-        public void Next()
-        {
-            List<YYnisonPlayableItem> list = State.PlayerState.PlayerQueue.PlayableList;
-
-            if (State.PlayerState.PlayerQueue.EntityType == YYnisonEntityType.Radio)
-            {
-                YYnisonPlayableItem next = State.PlayerState.PlayerQueue.Queue.WaveQueue.RecommendedPlayableList
-                    .FirstOrDefault();
-
-                list.RemoveAt(0);
-                list.Add(next);
-
-                UpdateState();
-            }
-
-            if (State.PlayerState.PlayerQueue.CurrentPlayableIndex < list.Count - 1)
-            {
-                State.PlayerState.PlayerQueue.CurrentPlayableIndex++;
-                UpdateState();
-            }
-        }
-
-        public void Previous()
-        {
-
-        }
-        */
-
-        #endregion Плеер
-
-        internal YnisonPlayer(YandexMusicApi api, AuthStorage authStorage)
-        {
-            API = api;
-            storage = authStorage;
-
-            redirector = new();
-            state = new();
-        }
-
-
-
-        #region IDisposable
-
+    /// <summary>Освобождает ресурсы.</summary>
     public void Dispose()
     {
-            redirector?.StopReceive();
-            redirector?.Dispose();
-        }
-
-        #endregion IDisposable
+        _redirector?.Dispose();
+        _state?.Dispose();
+        _redirector = null;
+        _state = null;
+        GC.SuppressFinalize(this);
     }
 }

YandexMusic.API/Common/Ynison/YnisonWebSocket.cs

@@ -1,179 +1,142 @@
 using System.Net.WebSockets;
 using System.Text;
+using System.Text.Json;
 
-namespace YandexMusic.API.Common.Ynison
-{
+namespace YandexMusic.API.Common.Ynison;
+
+/// <summary>WebSocket-клиент для взаимодействия с протоколом Ynison.</summary>
 public class YnisonWebSocket : IDisposable
 {
-        #region Поля
+    private readonly ClientWebSocket _socketClient = new();
+    private CancellationTokenSource? _cancellationTokenSource;
+    private CancellationToken _cancellationToken;
+    private readonly StringBuilder _data = new();
+    private const int BufferSize = 4096;
 
-        private readonly JsonSerializerSettings jsonSettings = new()
+    /// <summary>Флаг, указывает, открыто ли соединение.</summary>
+    public bool IsConnected => _socketClient.State == WebSocketState.Open;
+
+    /// <summary>Событие получения сообщения.</summary>
+    public event EventHandler<ReceiveEventArgs>? OnReceive;
+
+    /// <summary>Событие закрытия соединения.</summary>
+    public event EventHandler<CloseEventArgs>? OnClose;
+
+    /// <summary>Аргументы события получения данных.</summary>
+    public class ReceiveEventArgs : EventArgs
     {
-            Converters = new List<JsonConverter> {
-                new StringEnumConverter {
-                    NamingStrategy = new CamelCaseNamingStrategy()
-                }
-            },
-            NullValueHandling = NullValueHandling.Ignore
-        };
-
-        private readonly ClientWebSocket socketClient = new();
-
-        private CancellationTokenSource cancellationTokenSource = new();
-        private CancellationToken cancellation;
-
-        private readonly StringBuilder data = new();
-        private readonly int size = 4096;
-
-        #endregion Поля
-
-        #region Свойства
-
-        public bool IsConnected => socketClient.State == WebSocketState.Open;
-
-        #endregion Свойства
-
-        #region События
-
-        public class ReceiveEventArgs
-        {
-            public string Data { get; internal set; }
+        /// <summary>Полученные данные (JSON-строка).</summary>
+        public string Data { get; init; } = null!;
     }
 
-        public delegate void OnReceiveEventHandler(YnisonWebSocket socket, ReceiveEventArgs args);
-        /// <summary>
-        /// Получение данных
-        /// </summary>
-        public event OnReceiveEventHandler OnReceive;
-
-        public class CloseEventArgs
+    /// <summary>Аргументы события закрытия соединения.</summary>
+    public class CloseEventArgs : EventArgs
     {
-            public WebSocketCloseStatus? Status { get; set; }
-            public string Description { get; set; }
+        /// <summary>Статус закрытия.</summary>
+        public WebSocketCloseStatus? Status { get; init; }
+        /// <summary>Описание причины закрытия.</summary>
+        public string? Description { get; init; }
     }
 
-        public delegate void OnCloseEventHandler(YnisonWebSocket socket, CloseEventArgs args);
-        /// <summary>
-        /// Закрытие соединения
-        /// </summary>
-        public event OnCloseEventHandler OnClose;
-
-        #endregion События
-
-        #region Вспомогательные функции
-
-        private string SerializeJson(object obj)
+    private static string GetProtocolData(string deviceId, string? redirectTicket)
     {
-            return JsonConvert.SerializeObject(obj, jsonSettings);
-        }
-
-        private string GetProtocolData(string deviceId, string redirectTicket)
+        var deviceInfo = new Dictionary<string, object>
         {
-            Dictionary<string, object> deviceInfo = new() {
             { "app_name", "Chrome" },
             { "type", 1 }
         };
-
-            Dictionary<string, string> protocol = new() {
+        var protocol = new Dictionary<string, string>
+        {
             { "Ynison-Device-Id", deviceId },
-                { "Ynison-Device-Info", SerializeJson(deviceInfo) }
+            { "Ynison-Device-Info", JsonSerializer.Serialize(deviceInfo) }
         };
-
         if (!string.IsNullOrEmpty(redirectTicket))
             protocol.Add("Ynison-Redirect-Ticket", redirectTicket);
-
-            return SerializeJson(protocol);
+        return JsonSerializer.Serialize(protocol);
     }
 
-        private async Task<string> ReadSocketContent()
+    private async Task<string> ReadSocketContentAsync()
     {
-            byte[] buffer = new byte[size];
+        var buffer = new byte[BufferSize];
         WebSocketReceiveResult result;
-
         do
         {
-                result = await socketClient.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
-                data.Append(Encoding.UTF8.GetString(buffer, 0, result.Count));
+            result = await _socketClient.ReceiveAsync(new ArraySegment<byte>(buffer), _cancellationToken);
+            _data.Append(Encoding.UTF8.GetString(buffer, 0, result.Count));
         } while (!result.EndOfMessage);
-
-            return data.ToString();
+        return _data.ToString();
     }
 
-        #endregion Вспомогательные функции
-
-
-
-        public bool Connect(AuthStorage storage, string url, string redirectTicket = null)
+    /// <summary>Подключается к WebSocket.</summary>
+    /// <param name="storage">Хранилище авторизации.</param>
+    /// <param name="url">URL WebSocket.</param>
+    /// <param name="redirectTicket">Тикет перенаправления (опционально).</param>
+    public async Task ConnectAsync(AuthStorage storage, string url, string? redirectTicket = null)
     {
-            socketClient.Options.AddSubProtocol("Bearer");
+        _socketClient.Options.AddSubProtocol("Bearer");
+        var protocolData = GetProtocolData(storage.DeviceId, redirectTicket);
+        _socketClient.Options.SetRequestHeader("Sec-WebSocket-Protocol", $"Bearer, v2, {protocolData}");
+        _socketClient.Options.SetRequestHeader("Origin", "https://music.yandex.ru");
+        _socketClient.Options.SetRequestHeader("Authorization", $"OAuth {storage.Token}");
+        _socketClient.Options.Proxy = storage.Context.WebProxy;
 
-            socketClient.Options.SetRequestHeader("Sec-WebSocket-Protocol", $"Bearer, v2, {GetProtocolData(storage.DeviceId, redirectTicket)}");
-            socketClient.Options.SetRequestHeader("Origin", "https://music.yandex.ru");
-            socketClient.Options.SetRequestHeader("Authorization", $"OAuth {storage.Token}");
+        _cancellationTokenSource = new CancellationTokenSource();
+        _cancellationToken = _cancellationTokenSource.Token;
 
-            socketClient.Options.Proxy = storage.Context.WebProxy;
-
-            socketClient.ConnectAsync(new Uri(url), CancellationToken.None)
-                .GetAwaiter()
-                .GetResult();
-
-            cancellation = cancellationTokenSource.Token;
-
-            return socketClient.State == WebSocketState.Open;
+        await _socketClient.ConnectAsync(new Uri(url), CancellationToken.None);
     }
 
-        public async Task BeginReceive()
+    /// <summary>Начинает асинхронный приём сообщений.</summary>
+    public async Task BeginReceiveAsync()
     {
-            if (socketClient.State != WebSocketState.Open)
+        if (_socketClient.State != WebSocketState.Open)
             return;
 
-            do
+        try
         {
-                string content = await ReadSocketContent();
-                OnReceive?.Invoke(this, new ReceiveEventArgs
+            while (!_cancellationToken.IsCancellationRequested && _socketClient.State == WebSocketState.Open)
             {
-                    Data = content
-                });
-
-                data.Clear();
-            } while (!cancellation.IsCancellationRequested && socketClient.State == WebSocketState.Open);
-
-            OnClose?.Invoke(this, new CloseEventArgs
+                var content = await ReadSocketContentAsync();
+                OnReceive?.Invoke(this, new ReceiveEventArgs { Data = content });
+                _data.Clear();
+            }
+        }
+        catch (OperationCanceledException)
         {
-                Status = socketClient.CloseStatus,
-                Description = socketClient.CloseStatusDescription
-            });
-
-            await socketClient.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
+            // Ожидаемая отмена
+        }
+        finally
+        {
+            var closeStatus = _socketClient.CloseStatus;
+            var closeDesc = _socketClient.CloseStatusDescription;
+            OnClose?.Invoke(this, new CloseEventArgs { Status = closeStatus, Description = closeDesc });
+            if (_socketClient.State == WebSocketState.Open)
+                await _socketClient.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
+        }
     }
 
-
-        public ValueTask Send(string json)
+    /// <summary>Отправляет JSON-сообщение.</summary>
+    /// <param name="json">JSON-строка.</param>
+    public async ValueTask SendAsync(string json)
     {
-            ReadOnlyMemory<byte> message = new(Encoding.UTF8.GetBytes(json));
-            return socketClient.SendAsync(message, WebSocketMessageType.Text, false, CancellationToken.None);
+        var bytes = Encoding.UTF8.GetBytes(json);
+        await _socketClient.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text, true, _cancellationToken);
     }
 
-        public Task StopReceive()
+    /// <summary>Останавливает приём сообщений.</summary>
+    public async Task StopReceiveAsync()
     {
-            if (socketClient.State != WebSocketState.Open)
-                return Task.CompletedTask;
-
-            cancellationTokenSource.Cancel(false);
-
-            return Task.CompletedTask;
+        if (_cancellationTokenSource != null && !_cancellationTokenSource.IsCancellationRequested)
+        {
+            await _cancellationTokenSource.CancelAsync();
+        }
     }
 
-
-
-        #region IDisposable
-
+    /// <summary>Освобождает ресурсы.</summary>
     public void Dispose()
     {
-            socketClient?.Dispose();
-            cancellationTokenSource?.Dispose();
-        }
-
-        #endregion IDisposable
+        _cancellationTokenSource?.Dispose();
+        _socketClient.Dispose();
+        GC.SuppressFinalize(this);
     }
 }

YandexMusic.API/Extensions/API/YAlbumExtensions.cs

@@ -1,7 +1,7 @@
 using YandexMusic.API.Models.Album;
 
-namespace YandexMusic.API.Extensions.API
-{
+namespace YandexMusic.API.Extensions.API;
+
 /// <summary>
 /// Методы-расширения для альбома
 /// </summary>
@@ -22,4 +22,3 @@ namespace YandexMusic.API.Extensions.API
         return RemoveLikeAsync(album).GetAwaiter().GetResult();
     }
 }
-}

YandexMusic.API/Extensions/API/YAlbumExtensionsAsync.cs

@@ -1,7 +1,7 @@
 using YandexMusic.API.Models.Album;
 
-namespace YandexMusic.API.Extensions.API
-{
+namespace YandexMusic.API.Extensions.API;
+
 /// <summary>
 /// Методы-расширения для альбома
 /// </summary>
@@ -27,4 +27,3 @@ namespace YandexMusic.API.Extensions.API
             .Result;
     }
 }
-}

YandexMusic.API/Extensions/API/YArtistExtensions.cs

@@ -1,8 +1,8 @@
 using YandexMusic.API.Models.Artist;
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Extensions.API
-{
+namespace YandexMusic.API.Extensions.API;
+
 /// <summary>
 /// Методы-расширения для исполнителя
 /// </summary>
@@ -33,4 +33,3 @@ namespace YandexMusic.API.Extensions.API
         return RemoveLikeAsync(artist).GetAwaiter().GetResult();
     }
 }
-}

YandexMusic.API/Extensions/API/YArtistExtensionsAsync.cs

@@ -1,8 +1,8 @@
 using YandexMusic.API.Models.Artist;
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Extensions.API
-{
+namespace YandexMusic.API.Extensions.API;
+
 /// <summary>
 /// Методы-расширения для исполнителя
 /// </summary>
@@ -38,4 +38,3 @@ namespace YandexMusic.API.Extensions.API
             .Result;
     }
 }
-}

YandexMusic.API/Extensions/API/YPlaylistExtensions.cs

@@ -1,8 +1,8 @@
 using YandexMusic.API.Models.Playlist;
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Extensions.API
-{
+namespace YandexMusic.API.Extensions.API;
+
 /// <summary>
 /// Методы-расширения для плейлиста
 /// </summary>
@@ -53,4 +53,3 @@ namespace YandexMusic.API.Extensions.API
         return UploadTracksAsync(playlist, filePath, fileName).GetAwaiter().GetResult();
     }
 }
-}

YandexMusic.API/Extensions/API/YPlaylistExtensionsAsync.cs

@@ -1,8 +1,8 @@
 using YandexMusic.API.Models.Playlist;
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Extensions.API
-{
+namespace YandexMusic.API.Extensions.API;
+
 /// <summary>
 /// Методы-расширения для плейлиста
 /// </summary>
@@ -69,4 +69,3 @@ namespace YandexMusic.API.Extensions.API
             .Result == "CREATED";
     }
 }
-}

YandexMusic.API/Extensions/API/YStationResultExtensions.cs

@@ -1,8 +1,8 @@
 using YandexMusic.API.Models.Radio;
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Extensions.API
-{
+namespace YandexMusic.API.Extensions.API;
+
 /// <summary>
 /// Методы-расширения для радиостанции
 /// </summary>
@@ -23,4 +23,3 @@ namespace YandexMusic.API.Extensions.API
         return SendFeedBackAsync(station, type, track, batchId, totalPlayedSeconds).GetAwaiter().GetResult();
     }
 }
-}

YandexMusic.API/Extensions/API/YStationResultExtensionsAsync.cs

@@ -1,8 +1,8 @@
 using YandexMusic.API.Models.Radio;
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Extensions.API
-{
+namespace YandexMusic.API.Extensions.API;
+
 /// <summary>
 /// Методы-расширения для радиостанции
 /// </summary>
@@ -25,4 +25,3 @@ namespace YandexMusic.API.Extensions.API
         return station.Context.API.Radio.SendStationFeedBackAsync(station.Context.Storage, station, type, track, batchId, totalPlayedSeconds);
     }
 }
-}

YandexMusic.API/Extensions/API/YTrackExtensions.cs

@@ -1,7 +1,7 @@
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Extensions.API
-{
+namespace YandexMusic.API.Extensions.API;
+
 /// <summary>
 /// Методы-расширения для трека
 /// </summary>
@@ -52,4 +52,3 @@ namespace YandexMusic.API.Extensions.API
         return SimilarAsync(track).GetAwaiter().GetResult();
     }
 }
-}

YandexMusic.API/Extensions/API/YTrackExtensionsAsync.cs

@@ -1,7 +1,7 @@
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Extensions.API
-{
+namespace YandexMusic.API.Extensions.API;
+
 /// <summary>
 /// Методы-расширения для трека
 /// </summary>
@@ -58,4 +58,3 @@ namespace YandexMusic.API.Extensions.API
             .Result;
     }
 }
-}

YandexMusic.API/Extensions/HttpRequestHeaderExtensions.cs

@@ -1,7 +1,7 @@
 using System.Net;
 
-namespace YandexMusic.API.Extensions
-{
+namespace YandexMusic.API.Extensions;
+
 public static class HttpRequestHeaderExtensions
 {
     public static string GetName(this HttpRequestHeader header)
@@ -9,4 +9,3 @@ namespace YandexMusic.API.Extensions
         return header.ToString().SplitByCapitalLetter("-");
     }
 }
-}

YandexMusic.API/Extensions/StringExtensions.cs

@@ -1,7 +1,7 @@
 using System.Text.RegularExpressions;
 
-namespace YandexMusic.API.Extensions
-{
+namespace YandexMusic.API.Extensions;
+
 public static class StringExtensions
 {
     public static string ReplaceRegex(this string str, string regExpr, string replStr, RegexOptions options = RegexOptions.IgnoreCase)
@@ -47,4 +47,3 @@ namespace YandexMusic.API.Extensions
             : new string[] { };
     }
 }
-}

YandexMusic.API/Models/Account/YAccessToken.cs

@@ -1,15 +1,20 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YAccessToken
 {
-        [JsonProperty("status")]
+    [JsonPropertyName("status")]
     public string Status { get; set; }
-        [JsonProperty("access_token")]
+
+    [JsonPropertyName("access_token")]
     public string AccessToken { get; set; }
-        [JsonProperty("expires_in")]
+
+    [JsonPropertyName("expires_in")]
     public string Expires { get; set; }
-        [JsonProperty("token_type")]
+
+    [JsonPropertyName("token_type")]
     public string TokenType { get; set; }
+
     public string Uid { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAccount.cs

@@ -1,25 +1,40 @@
+using System.Text.Json.Serialization;
 using YandexMusic.API.Models.Common;
 
-namespace YandexMusic.API.Models.Account
-{
+namespace YandexMusic.API.Models.Account;
+
 public class YAccount
 {
     public bool Child { get; set; }
+
     public string Birthday { get; set; }
+
     public string DisplayName { get; set; }
+
     public string FirstName { get; set; }
+
     public string FullName { get; set; }
+
     public bool HostedUser { get; set; }
+
     public string Login { get; set; }
+
     public bool NonOwnerFamilyMember { get; set; }
+
     public DateTime Now { get; set; }
-        [JsonProperty("passport-phones")]
+
+    [JsonPropertyName("passport-phones")]
     public List<YPhone> PassportPhones { get; set; }
+
     public int Region { get; set; }
+
     public string RegionCode { get; set; }
+
     public DateTime RegisteredAt { get; set; }
+
     public string SecondName { get; set; }
+
     public bool ServiceAvailable { get; set; }
+
     public string Uid { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAccountResult.cs

@@ -1,26 +1,37 @@
+using System.Text.Json.Serialization;
 using YandexMusic.API.Models.Common;
 
-namespace YandexMusic.API.Models.Account
-{
+namespace YandexMusic.API.Models.Account;
+
 public class YAccountResult
 {
     public YAccount Account { get; set; }
+
     public string DefaultEmail { get; set; }
+
     public List<string> HasOptions { get; set; }
+
     public YMasterHub MasterHub { get; set; }
+
     public YPermissions Permissions { get; set; }
+
     public YPlus Plus { get; set; }
+
     public bool PretrialActive { get; set; }
+
     public bool SubEditor { get; set; }
+
     public int SubEditorLevel { get; set; }
+
     public YSubscription Subscription { get; set; }
+
     public YBar BarBelow { get; set; }
-        // Повторяющееся свойство с другим названием
-        [JsonProperty("bar-below")]
+
+    [JsonPropertyName("bar-below")]
     private YBar BarBelow2
     {
         set => BarBelow = value;
     }
+
     public string Userhash { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthBase.cs

@@ -1,12 +1,13 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthBase
 {
     public YAuthStatus Status { get; set; }
 
-        [JsonProperty("redirect_url")]
+    [JsonPropertyName("redirect_url")]
     public string RedirectUrl { get; set; }
 
     public List<YAuthError> Errors { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthCaptcha.cs

@@ -1,5 +1,7 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthCaptcha : YAuthBase
 {
     public string Id { get; set; }
@@ -18,11 +20,10 @@
 
     public YAuthCaptchaVoice Voice { get; set; }
 
-        [JsonProperty("image_url")]
+    [JsonPropertyName("image_url")]
     public string ImageUrl { get; set; }
 
     public string Key { get; set; }
 
     public string Static { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthCaptchaError.cs

@@ -1,8 +1,7 @@
-namespace YandexMusic.API.Models.Account
-{
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthCaptchaError
 {
     public string Message { get; set; }
     public YAuthCaptchaErrorCode Code { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthCaptchaErrorCode.cs

@@ -1,9 +1,8 @@
-namespace YandexMusic.API.Models.Account
-{
+namespace YandexMusic.API.Models.Account;
+
 public enum YAuthCaptchaErrorCode
 {
     MissingValue,
     CaptchaLocate,
     Incorrect
 }
-}

YandexMusic.API/Models/Account/YAuthCaptchaOptions.cs

@@ -1,7 +1,6 @@
-namespace YandexMusic.API.Models.Account
-{
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthCaptchaOptions
 {
     public bool AsyncCheck { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthCaptchaVoice.cs

@@ -1,10 +1,11 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthCaptchaVoice
 {
     public string Url { get; set; }
 
-        [JsonProperty("intro_url")]
+    [JsonPropertyName("intro_url")]
     public string IntroUrl { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthError.cs

@@ -1,22 +1,27 @@
 using System.Runtime.Serialization;
 
-namespace YandexMusic.API.Models.Account
-{
+namespace YandexMusic.API.Models.Account;
+
 public enum YAuthError
 {
     [EnumMember(Value = "authorization.invalid")]
     AuthorizationInvalid,
+
     [EnumMember(Value = "sessionid.invalid")]
     SessionIdInvalid,
+
     [EnumMember(Value = "password.not_matched")]
     PasswordNotMatched,
+
     [EnumMember(Value = "password.empty")]
     PasswordEmpty,
+
     [EnumMember(Value = "captcha.required")]
     CaptchaRequired,
+
     [EnumMember(Value = "captcha.not_matched")]
     CaptchaNotMatched,
+
     [EnumMember(Value = "oauth_token.invalid")]
-        OAuthTokenInvalid
-    }
+    OAuthTokenInvalid,
 }

YandexMusic.API/Models/Account/YAuthLetter.cs

@@ -1,9 +1,8 @@
-namespace YandexMusic.API.Models.Account
-{
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthLetter : YAuthBase
 {
     public List<string> Code { get; set; }
 
     public string Id { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthLetterStatus.cs

@@ -1,11 +1,12 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthLetterStatus : YAuthBase
 {
-        [JsonProperty("magic_link_confirmed")]
+    [JsonPropertyName("magic_link_confirmed")]
     public bool MagicLinkConfirmed { get; set; }
 
-        [JsonProperty("track_id")]
+    [JsonPropertyName("track_id")]
     public string TrackId { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthMethod.cs

@@ -1,22 +1,29 @@
 using System.Runtime.Serialization;
 
-namespace YandexMusic.API.Models.Account
-{
+namespace YandexMusic.API.Models.Account;
+
 public enum YAuthMethod
 {
     Password,
+
     [EnumMember(Value = "magic_x_token")]
     MagicToken,
+
     [EnumMember(Value = "magic_x_token_with_pictures")]
     MagicTokenWithPictures,
+
     [EnumMember(Value = "magic_link")]
     MagicLink,
+
     Magic,
+
     Otp,
+
     [EnumMember(Value = "social_gg")]
     Social,
+
     WebAuthN,
+
     [EnumMember(Value = "sms_code")]
-        SmsCode
-    }
+    SmsCode,
 }

YandexMusic.API/Models/Account/YAuthQr.cs

@@ -1,11 +1,12 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthQR : YAuthBase
 {
-        [JsonProperty("track_id")]
+    [JsonPropertyName("track_id")]
     public string TrackId { get; set; }
 
-        [JsonProperty("csrf_token")]
+    [JsonPropertyName("csrf_token")]
     public string CsrfToken { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthQrStatus.cs

@@ -1,13 +1,15 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthQRStatus : YAuthBase
 {
-        [JsonProperty("default_uid")]
+    [JsonPropertyName("default_uid")]
     public int DefaultUid { get; set; }
 
     public string RetPath { get; set; }
 
-        [JsonProperty("track_id")]
+    [JsonPropertyName("track_id")]
     public string TrackId { get; set; }
 
     public string Id { get; set; }
@@ -16,4 +18,3 @@
 
     public YAuthCaptcha Captcha { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthStatus.cs

@@ -1,8 +1,7 @@
-namespace YandexMusic.API.Models.Account
-{
+namespace YandexMusic.API.Models.Account;
+
 public enum YAuthStatus
 {
     Ok,
     Error
 }
-}

YandexMusic.API/Models/Account/YAuthToken.cs

@@ -1,11 +1,12 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthToken
 {
-        [JsonProperty("csfr_token")]
+    [JsonPropertyName("csfr_token")]
     public string CsfrToken { get; set; }
 
-        [JsonProperty("track_id")]
+    [JsonPropertyName("track_id")]
     public string TrackId { get; set; }
 }
-}

YandexMusic.API/Models/Account/YAuthTypes.cs

@@ -1,47 +1,48 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YAuthTypes : YAuthBase
 {
-        [JsonProperty("primary_alias_type")]
+    [JsonPropertyName("primary_alias_type")]
     public string PrimaryAliasType { get; set; }
 
-        [JsonProperty("csrf_token")]
+    [JsonPropertyName("csrf_token")]
     public string CsrfToken { get; set; }
 
     public string LocCsrf { get; set; }
 
-        [JsonProperty("use_new_suggest_by_phone")]
+    [JsonPropertyName("use_new_suggest_by_phone")]
     public bool UseNewSuggestByPhone { get; set; }
 
-        [JsonProperty("is_rfc_2fa_enabled")]
+    [JsonPropertyName("is_rfc_2fa_enabled")]
     public bool IsRfc2faEnabled { get; set; }
 
-        [JsonProperty("track_id")]
+    [JsonPropertyName("track_id")]
     public string TrackId { get; set; }
 
-        [JsonProperty("can_authorize")]
+    [JsonPropertyName("can_authorize")]
     public string CanAuthorize { get; set; }
 
-        [JsonProperty("preferred_auth_method")]
+    [JsonPropertyName("preferred_auth_method")]
     public YAuthMethod PreferredAuthMethod { get; set; }
 
-        [JsonProperty("auth_methods")]
+    [JsonPropertyName("auth_methods")]
     public List<YAuthMethod> AuthMethods { get; set; }
 
-        [JsonProperty("can_register")]
+    [JsonPropertyName("can_register")]
     public bool CanRegister { get; set; }
 
-        [JsonProperty("location_id")]
+    [JsonPropertyName("location_id")]
     public string LocationId { get; set; }
 
     public string Country { get; set; }
 
-        [JsonProperty("phone_number")]
+    [JsonPropertyName("phone_number")]
     public YPhoneNumber PhoneNumberNumber { get; set; }
 
-        [JsonProperty("magic_link_email")]
+    [JsonPropertyName("magic_link_email")]
     public string MagicLinkEmail { get; set; }
 
     public string TractorTargetLocationHost { get; set; }
 }
-}

YandexMusic.API/Models/Account/YBar.cs

@@ -1,7 +1,7 @@
 using YandexMusic.API.Models.Common;
 
-namespace YandexMusic.API.Models.Account
-{
+namespace YandexMusic.API.Models.Account;
+
 public class YBar : YStyle
 {
     public string AlertId { get; set; }
@@ -11,4 +11,3 @@ namespace YandexMusic.API.Models.Account
     public bool CloseButton { get; set; }
     public YCloseButtonStyles CloseButtonStyles { get; set; }
 }
-}

YandexMusic.API/Models/Account/YLoginInfo.cs

@@ -1,31 +1,32 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YLoginInfo
 {
     public string Id { get; set; }
     public string Login { get; set; }
-        [JsonProperty("client_id")]
+    [JsonPropertyName("client_id")]
     public string ClientId { get; set; }
-        [JsonProperty("display_name")]
+    [JsonPropertyName("display_name")]
     public string DisplayName { get; set; }
-        [JsonProperty("real_name")]
+    [JsonPropertyName("real_name")]
     public string RealName { get; set; }
-        [JsonProperty("first_name")]
+    [JsonPropertyName("first_name")]
     public string FirstName { get; set; }
-        [JsonProperty("last_name")]
+    [JsonPropertyName("last_name")]
     public string LastName { get; set; }
     public string Sex { get; set; }
-        [JsonProperty("default_email")]
+    [JsonPropertyName("default_email")]
     public string DefaultEmail { get; set; }
     public List<string> Emails { get; set; }
     public string Birthday { get; set; }
-        [JsonProperty("default_avatar_id")]
+    [JsonPropertyName("default_avatar_id")]
     public string DefaultAvatarId { get; set; }
 
     public string AvatarUrl => $"https://avatars.mds.yandex.net/get-yapic/{DefaultAvatarId}/islands-200";
-        [JsonProperty("is_avatar_empty")]
+    [JsonPropertyName("is_avatar_empty")]
     public bool IsAvatarEmpty { get; set; }
     public string PsuId { get; set; }
 
 }
-}

YandexMusic.API/Models/Account/YPhoneNumber.cs

@@ -1,20 +1,21 @@
-namespace YandexMusic.API.Models.Account
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account;
+
 public class YPhoneNumber
 {
-        [JsonProperty("masked_e164")]
+    [JsonPropertyName("masked_e164")]
     public string MaskedE164 { get; set; }
 
     public string E164 { get; set; }
 
     public string International { get; set; }
 
-        [JsonProperty("masked_original")]
+    [JsonPropertyName("masked_original")]
     public string MaskedOriginal { get; set; }
 
     public string Original { get; set; }
 
-        [JsonProperty("masked_international")]
+    [JsonPropertyName("masked_international")]
     public string MaskedInternational { get; set; }
 }
-}

YandexMusic.API/Models/Account/YShortAccountInfo.cs

@@ -1,8 +1,10 @@
-namespace YandexMusic.API.Models.Account
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Account
 {
     public class YShortAccountInfo : YAuthBase
     {
-        [JsonProperty("public_id")]
+        [JsonPropertyName("public_id")]
         public string PublicId { get; set; }
 
         public string Uid { get; set; }
@@ -13,69 +15,69 @@
 
         public string Birthday { get; set; }
 
-        [JsonProperty("has_password")]
+        [JsonPropertyName("has_password")]
         public bool HasPassword { get; set; }
 
         public List<string> Partitions { get; set; }
 
-        [JsonProperty("primary_alias_type")]
+        [JsonPropertyName("primary_alias_type")]
         public int PrimaryAliasType { get; set; }
 
-        [JsonProperty("display_name")]
+        [JsonPropertyName("display_name")]
         public string DisplayName { get; set; }
 
-        [JsonProperty("normalized_display_login")]
+        [JsonPropertyName("normalized_display_login")]
         public string NormalizedDisplayLogin { get; set; }
 
-        [JsonProperty("x_token_issued_at")]
+        [JsonPropertyName("x_token_issued_at")]
         public int XTokenIssuedAt { get; set; }
 
-        [JsonProperty("display_login")]
+        [JsonPropertyName("display_login")]
         public string DisplayLogin { get; set; }
 
-        [JsonProperty("public_name")]
+        [JsonPropertyName("public_name")]
         public string PublicName { get; set; }
 
-        [JsonProperty("avatar_url")]
+        [JsonPropertyName("avatar_url")]
         public string AvatarUrl { get; set; }
 
-        [JsonProperty("native_default_email")]
+        [JsonPropertyName("native_default_email")]
         public string NativeDefaultEmail { get; set; }
 
-        [JsonProperty("has_plus")]
+        [JsonPropertyName("has_plus")]
         public bool HasPlus { get; set; }
 
-        [JsonProperty("location_id")]
+        [JsonPropertyName("location_id")]
         public int LocationId { get; set; }
 
-        [JsonProperty("gender")]
+        [JsonPropertyName("gender")]
         public string Gender { get; set; }
 
-        [JsonProperty("is_avatar_empty")]
+        [JsonPropertyName("is_avatar_empty")]
         public bool IsAvatarEmpty { get; set; }
 
-        [JsonProperty("machine_readable_login")]
+        [JsonPropertyName("machine_readable_login")]
         public string MachineReadableLogin { get; set; }
 
-        [JsonProperty("has_cards")]
+        [JsonPropertyName("has_cards")]
         public bool HasCards { get; set; }
 
-        [JsonProperty("has_family")]
+        [JsonPropertyName("has_family")]
         public bool HasFamily { get; set; }
 
-        [JsonProperty("picture_login_forbidden")]
+        [JsonPropertyName("picture_login_forbidden")]
         public bool PictureLoginForbidden { get; set; }
 
-        [JsonProperty("can_account_join_master")]
+        [JsonPropertyName("can_account_join_master")]
         public bool CanAccountJoinMaster { get; set; }
 
-        [JsonProperty("secure_phone_number")]
+        [JsonPropertyName("secure_phone_number")]
         public string SecurePhoneNumber { get; set; }
 
-        [JsonProperty("x_token_client_id")]
+        [JsonPropertyName("x_token_client_id")]
         public string XTokenClientId { get; set; }
 
-        [JsonProperty("x_token_need_reset")]
+        [JsonPropertyName("x_token_need_reset")]
         public bool XTokenNeedReset { get; set; }
     }
 }

YandexMusic.API/Models/Album/YAlbum.cs

@@ -1,50 +1,12 @@
+using System.Text.Json.Serialization;
 using YandexMusic.API.Models.Artist;
 using YandexMusic.API.Models.Common;
 using YandexMusic.API.Models.Common.Cover;
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Models.Album
-{
-    public sealed class YLabelConverter : JsonConverter
-    {
-        public override bool CanConvert(Type objectType)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-        {
-            if (reader.TokenType == JsonToken.Null)
-                return null;
-
-            JArray jArray = JArray.Load(reader);
-            JTokenType tokenType = jArray.FirstOrDefault()?.Type ?? JTokenType.String;
-            object label;
-
-            try
-            {
-                label = tokenType switch
-                {
-                    JTokenType.Object => jArray.ToObject<List<YLabel>>(),
-                    _ => jArray.ToObject<List<string>>()
-                };
-            }
-            catch (Exception ex)
-            {
-                throw new Exception($"Ошибка десериализации типа \"{objectType.Name}\".", ex);
-            }
-
-            return label;
-        }
-
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-        {
-            JArray array = JArray.FromObject(value);
-
-            array.WriteTo(writer);
-        }
-    }
+namespace YandexMusic.API.Models.Album;
 
+/// <summary>Модель альбома.</summary>
 public class YAlbum : YBaseModel
 {
     public YButton ActionButton { get; set; }
@@ -95,4 +57,3 @@ namespace YandexMusic.API.Models.Album
     public List<List<YTrack>> Volumes { get; set; }
     public int Year { get; set; }
 }
-}

YandexMusic.API/Models/Album/YLabelConverter.cs

@@ -0,0 +1,32 @@
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using YandexMusic.API.Models.Common;
+
+namespace YandexMusic.API.Models.Album;
+
+/// <summary>Конвертер для поля Labels, которое может быть списком строк или объектов.</summary>
+public sealed class YLabelConverter : JsonConverter<object>
+{
+    public override object Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        if (reader.TokenType != JsonTokenType.StartArray)
+            throw new JsonException("Ожидается массив");
+
+        var list = new List<object>();
+        while (reader.Read())
+        {
+            if (reader.TokenType == JsonTokenType.EndArray) break;
+            if (reader.TokenType == JsonTokenType.String)
+                list.Add(reader.GetString()!);
+            else if (reader.TokenType == JsonTokenType.StartObject)
+            {
+                var label = JsonSerializer.Deserialize<YLabel>(ref reader, options);
+                list.Add(label!);
+            }
+        }
+        return list;
+    }
+
+    public override void Write(Utf8JsonWriter writer, object value, JsonSerializerOptions options)
+        => JsonSerializer.Serialize(writer, value, options);
+}

YandexMusic.API/Models/Artist/YArtist.cs

@@ -1,8 +1,9 @@
+using System.Text.Json.Serialization;
 using YandexMusic.API.Models.Common;
 using YandexMusic.API.Models.Common.Cover;
 
-namespace YandexMusic.API.Models.Artist
-{
+namespace YandexMusic.API.Models.Artist;
+
 public class YArtist : YBaseModel
 {
     public YButton ActionButton { get; set; }
@@ -38,4 +39,3 @@ namespace YandexMusic.API.Models.Artist
     public bool HasTrailer { get; set; }
     public YTrailer Trailer { get; set; }
 }
-}

YandexMusic.API/Models/Artist/YArtistBriefInfo.cs

@@ -1,16 +1,17 @@
+using System.Text.Json.Serialization;
 using YandexMusic.API.Models.Album;
 using YandexMusic.API.Models.Common;
 using YandexMusic.API.Models.Common.Cover;
 using YandexMusic.API.Models.Playlist;
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Models.Artist
-{
+namespace YandexMusic.API.Models.Artist;
+
 public class YArtistBriefInfo
 {
     public YButton ActionButton { get; set; }
     public List<YAlbum> Albums { get; set; }
-        [JsonProperty(ItemConverterType = typeof(YCoverConverter))]
+    [JsonConverter(typeof(YCoverConverter))]
     public List<YCover> AllCovers { get; set; }
     public List<YAlbum> AlsoAlbums { get; set; }
     public YArtist Artist { get; set; }
@@ -33,4 +34,3 @@ namespace YandexMusic.API.Models.Artist
     public List<YVinyl> Vinyls { get; set; }
     public List<YLink> Links { get; set; }
 }
-}

YandexMusic.API/Models/Artist/YArtistCounts.cs

@@ -1,5 +1,5 @@
-namespace YandexMusic.API.Models.Artist
-{
+namespace YandexMusic.API.Models.Artist;
+
 public class YArtistCounts
 {
     public int AlsoAlbums { get; set; }
@@ -7,4 +7,3 @@ namespace YandexMusic.API.Models.Artist
     public int DirectAlbums { get; set; }
     public int Tracks { get; set; }
 }
-}

YandexMusic.API/Models/Artist/YArtistRatings.cs

@@ -1,9 +1,8 @@
-namespace YandexMusic.API.Models.Artist
-{
+namespace YandexMusic.API.Models.Artist;
+
 public class YArtistRatings
 {
     public int Day { get; set; }
     public int Month { get; set; }
     public int Week { get; set; }
 }
-}

YandexMusic.API/Models/Artist/YBandlinkScannerLink.cs

@@ -1,5 +1,5 @@
-namespace YandexMusic.API.Models.Artist
-{
+namespace YandexMusic.API.Models.Artist;
+
 public class YBandlinkScannerLink
 {
     public string Title { get; set; }
@@ -7,4 +7,3 @@
     public string Url { get; set; }
     public string ImgUrl { get; set; }
 }
-}

YandexMusic.API/Models/Artist/YConcert.cs

@@ -1,7 +1,8 @@
+using System.Text.Json.Serialization;
 using YandexMusic.API.Models.Common;
 
-namespace YandexMusic.API.Models.Artist
-{
+namespace YandexMusic.API.Models.Artist;
+
 public class YConcert
 {
     public string Address { get; set; }
@@ -12,7 +13,7 @@ namespace YandexMusic.API.Models.Artist
     public string ContentRating { get; set; }
     public List<decimal> Coordinates { get; set; }
     public YCashback Cashback { get; set; }
-        [JsonProperty("data-session-id")]
+    [JsonPropertyName("data-session-id")]
     public string DataSessionId { get; set; }
     public DateTime DateTime { get; set; }
     public string Hash { get; set; }
@@ -21,9 +22,8 @@ namespace YandexMusic.API.Models.Artist
     public string ImageUrl { get; set; }
     public string Map { get; set; }
     public string MapUrl { get; set; }
-        [JsonProperty("metro-stations")]
+    [JsonPropertyName("metro-stations")]
     public List<YMetroStation> MetroStations { get; set; }
     public string Place { get; set; }
     public YPrice MinPrice { get; set; }
 }
-}

YandexMusic.API/Models/Artist/YDeprecation.cs

@@ -1,7 +1,6 @@
-namespace YandexMusic.API.Models.Artist
-{
+namespace YandexMusic.API.Models.Artist;
+
 public class YDeprecation
 {
     public string TargetArtistId { get; set; }
 }
-}

YandexMusic.API/Models/Artist/YMetroStation.cs

@@ -1,9 +1,10 @@
-namespace YandexMusic.API.Models.Artist
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Artist;
+
 public class YMetroStation
 {
-        [JsonProperty("line-color")]
+    [JsonPropertyName("line-color")]
     public string LineColor { get; set; }
     public string Title { get; set; }
 }
-}

YandexMusic.API/Models/Artist/YTracksPage.cs

@@ -1,12 +1,11 @@
 using YandexMusic.API.Models.Common;
 using YandexMusic.API.Models.Track;
 
-namespace YandexMusic.API.Models.Artist
-{
+namespace YandexMusic.API.Models.Artist;
+
 public class YTracksPage
 {
     public YPager Pager { get; set; }
 
     public List<YTrack> Tracks { get; set; }
 }
-}

YandexMusic.API/Models/Common/Cover/YCover.cs

@@ -1,71 +1,35 @@
-namespace YandexMusic.API.Models.Common.Cover
+using System.Text.Json;
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Common.Cover;
+
+public class YCoverConverter : JsonConverter<YCover>
 {
-    public sealed class YCoverConverter : JsonConverter
+    public override YCover? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
     {
-        public override bool CanConvert(Type objectType)
+        if (reader.TokenType != JsonTokenType.StartObject) return null;
+        using var doc = JsonDocument.ParseValue(ref reader);
+        var root = doc.RootElement;
+        var type = root.TryGetProperty("type", out var t) ? t.GetString() : null;
+        if (root.TryGetProperty("error", out _)) type = "error";
+
+        return type switch
         {
-            return typeof(YCover).IsAssignableFrom(objectType);
+            "color" => JsonSerializer.Deserialize<YCoverColor>(root.GetRawText(), options),
+            "error" => JsonSerializer.Deserialize<YCoverError>(root.GetRawText(), options),
+            "from-artist-photos" or "from-album-cover" => JsonSerializer.Deserialize<YCoverImage>(root.GetRawText(), options),
+            "pic" => JsonSerializer.Deserialize<YCoverPic>(root.GetRawText(), options),
+            "mosaic" => JsonSerializer.Deserialize<YCoverMosaic>(root.GetRawText(), options),
+            _ => JsonSerializer.Deserialize<YCover>(root.GetRawText(), options)
+        };
     }
 
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-        {
-            if (reader.TokenType == JsonToken.Null)
-                return null;
-
-            JObject jObject = JObject.Load(reader);
-            YCover cover;
-
-            try
-            {
-                // Фиктивный тип, т.к. у такой обложки нет поля с типом
-                if (jObject["type"] == null)
-                    jObject.Add("type", "color");
-
-                YCoverType type = jObject["error"] != null
-                    ? YCoverType.Error
-                    : jObject["type"].ToObject<YCoverType>();
-
-                switch (type)
-                {
-                    case YCoverType.Error:
-                        cover = jObject.ToObject<YCoverError>();
-                        break;
-                    case YCoverType.Color:
-                        cover = jObject.ToObject<YCoverColor>();
-                        break;
-                    case YCoverType.FromAlbumCover:
-                    case YCoverType.FromArtistPhotos:
-                        cover = jObject.ToObject<YCoverImage>();
-                        break;
-                    case YCoverType.Pic:
-                        cover = jObject.ToObject<YCoverPic>();
-                        break;
-                    case YCoverType.Mosaic:
-                        cover = jObject.ToObject<YCoverMosaic>();
-                        break;
-                    default:
-                        cover = jObject.ToObject<YCover>();
-                        break;
-                }
-            }
-            catch (Exception ex)
-            {
-                throw new Exception($"Ошибка десериализации типа \"{objectType.Name}\".", ex);
-            }
-
-            return cover;
-        }
-
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-        {
-            JObject cover = JObject.FromObject(value, serializer);
-
-            cover.WriteTo(writer);
-        }
+    public override void Write(Utf8JsonWriter writer, YCover value, JsonSerializerOptions options)
+        => JsonSerializer.Serialize(writer, value, options);
 }
 
+[JsonConverter(typeof(YCoverConverter))]
 public class YCover
 {
     public YCoverType Type { get; set; }
 }
-}

YandexMusic.API/Models/Common/Cover/YCoverColor.cs

@@ -1,8 +1,7 @@
-namespace YandexMusic.API.Models.Common.Cover
-{
+namespace YandexMusic.API.Models.Common.Cover;
+
 public class YCoverColor : YCover
 {
     public string Uri { get; set; }
     public string Color { get; set; }
 }
-}

YandexMusic.API/Models/Common/Cover/YCoverError.cs

@@ -1,7 +1,6 @@
-namespace YandexMusic.API.Models.Common.Cover
-{
+namespace YandexMusic.API.Models.Common.Cover;
+
 public class YCoverError : YCover
 {
     public string Error { get; set; }
 }
-}

YandexMusic.API/Models/Common/Cover/YCoverImage.cs

@@ -1,8 +1,7 @@
-namespace YandexMusic.API.Models.Common.Cover
-{
+namespace YandexMusic.API.Models.Common.Cover;
+
 public class YCoverImage : YCover
 {
     public string Prefix { get; set; }
     public string Uri { get; set; }
 }
-}

YandexMusic.API/Models/Common/Cover/YCoverMosaic.cs

@@ -1,8 +1,7 @@
-namespace YandexMusic.API.Models.Common.Cover
-{
+namespace YandexMusic.API.Models.Common.Cover;
+
 public class YCoverMosaic : YCover
 {
     public bool Custom { get; set; }
     public List<string> ItemsUri { get; set; }
 }
-}

YandexMusic.API/Models/Common/Cover/YCoverPic.cs

@@ -1,5 +1,5 @@
-namespace YandexMusic.API.Models.Common.Cover
-{
+namespace YandexMusic.API.Models.Common.Cover;
+
 public class YCoverPic : YCover
 {
     public bool Custom { get; set; }
@@ -8,4 +8,3 @@ namespace YandexMusic.API.Models.Common.Cover
     public string Uri { get; set; }
     public string Version { get; set; }
 }
-}

YandexMusic.API/Models/Common/Cover/YCoverType.cs

@@ -1,8 +1,9 @@
 using System.Runtime.Serialization;
+using System.Text.Json.Serialization;
 
-namespace YandexMusic.API.Models.Common.Cover
-{
-    [JsonConverter(typeof(StringEnumConverter))]
+namespace YandexMusic.API.Models.Common.Cover;
+
+[JsonConverter(typeof(JsonStringEnumConverter))]
 public enum YCoverType
 {
     Color,
@@ -12,6 +13,5 @@ namespace YandexMusic.API.Models.Common.Cover
     [EnumMember(Value = "from-album-cover")]
     FromAlbumCover,
     Mosaic,
-        Pic
-    }
+    Pic,
 }

YandexMusic.API/Models/Common/YBaseModel.cs

@@ -1,8 +1,9 @@
-namespace YandexMusic.API.Models.Common
-{
+using System.Text.Json.Serialization;
+
+namespace YandexMusic.API.Models.Common;
+
 public class YBaseModel
 {
     [JsonIgnore]
     public YExecutionContext Context { get; set; }
 }
-}

YandexMusic.API/Models/Common/YButton.cs

@@ -1,12 +1,10 @@
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YButton : YStyle
 {
     public string Text { get; set; }
     public string Url { get; set; }
-#warning Дублирование?
     public string Uri { get; set; }
     public string Color { get; set; }
     public bool ViewBrowser { get; set; }
 }
-}

YandexMusic.API/Models/Common/YCashback.cs

@@ -1,7 +1,6 @@
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YCashback
 {
     public string Title { get; set; }
 }
-}

YandexMusic.API/Models/Common/YChart.cs

@@ -1,7 +1,7 @@
 using YandexMusic.API.Models.Landing.Entity.Entities;
 
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YChart
 {
     public int Position { get; set; }
@@ -9,4 +9,3 @@ namespace YandexMusic.API.Models.Common
     public int Shift { get; set; }
     public YChartProgress Progress { get; set; }
 }
-}

YandexMusic.API/Models/Common/YClip.cs

@@ -1,7 +1,7 @@
 using YandexMusic.API.Models.Artist;
 
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YClip
 {
     public List<YArtist> Artists { get; set; }
@@ -16,4 +16,3 @@ namespace YandexMusic.API.Models.Common
     public string Title { get; set; }
     public List<string> TrackIds { get; set; }
 }
-}

YandexMusic.API/Models/Common/YCloseButtonStyles.cs

@@ -1,8 +1,7 @@
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YCloseButtonStyles
 {
     public YStyle White { get; set; }
     public YStyle Black { get; set; }
 }
-}

YandexMusic.API/Models/Common/YCountsTracks.cs

@@ -1,9 +1,8 @@
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YCountsTracks
 {
     public int All { get; set; }
     public int Favorite { get; set; }
     public int Ugc { get; set; }
 }
-}

YandexMusic.API/Models/Common/YCustomWave.cs

@@ -1,5 +1,5 @@
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YCustomWave
 {
     public string AnimationUrl { get; set; }
@@ -8,4 +8,3 @@
     public string Position { get; set; }
     public string Title { get; set; }
 }
-}

YandexMusic.API/Models/Common/YDerivedColors.cs

@@ -1,5 +1,5 @@
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YDerivedColors
 {
     public string Average { get; set; }
@@ -7,4 +7,3 @@
     public string MiniPlayer { get; set; }
     public string Accent { get; set; }
 }
-}

YandexMusic.API/Models/Common/YDescription.cs

@@ -1,8 +1,7 @@
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YDescription
 {
     public string Text { get; set; }
     public string Uri { get; set; }
 }
-}

YandexMusic.API/Models/Common/YError.cs

@@ -1,8 +1,7 @@
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YError
 {
     public string Name { get; set; }
     public string Message { get; set; }
 }
-}

YandexMusic.API/Models/Common/YErrorResponse.cs

@@ -1,8 +1,7 @@
-namespace YandexMusic.API.Models.Common
-{
+namespace YandexMusic.API.Models.Common;
+
 public class YErrorResponse : Exception
 {
     public YInvocationInfo InvocationInfo { get; set; }
     public YError Error { get; set; }
 }
-}

YandexMusic.API/Models/Common/YExecutionContext.cs

@@ -1,57 +1,12 @@
 using YandexMusic.API.Common;
 
-namespace YandexMusic.API.Models.Common
-{
-    public sealed class YExecutionContextConverter : JsonConverter
-    {
-        #region Поля
-
-        private YandexMusicApi api;
-        private AuthStorage storage;
-
-        #endregion Поля
-
-        public override bool CanConvert(Type objectType)
-        {
-            return typeof(YBaseModel).IsAssignableFrom(objectType);
-        }
-
-        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-        {
-            try
-            {
-                YBaseModel obj = (YBaseModel)Activator.CreateInstance(objectType);
-                serializer.Populate(reader, obj);
-
-                obj.Context = new YExecutionContext
-                {
-                    API = api,
-                    Storage = storage
-                };
-
-                return obj;
-            }
-            catch (Exception ex)
-            {
-                throw new Exception($"Ошибка десериализации типа \"{objectType.Name}\".", ex);
-            }
-        }
-
-        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-        {
-            throw new NotImplementedException();
-        }
-
-        public YExecutionContextConverter(YandexMusicApi yandex, AuthStorage auth)
-        {
-            api = yandex;
-            storage = auth;
-        }
-    }
+namespace YandexMusic.API.Models.Common;
 
+/// <summary>Контекст выполнения, содержащий ссылки на API и хранилище.</summary>
 public class YExecutionContext
 {
-        public YandexMusicApi API { get; internal set; }
-        public AuthStorage Storage { get; internal set; }
-    }
+    /// <summary>Экземпляр основного API.</summary>
+    public YandexMusicApi API { get; internal set; } = null!;
+    /// <summary>Хранилище данных авторизации.</summary>
+    public AuthStorage Storage { get; internal set; } = null!;
 }