feat(api): artwork upload endpoint (#104)

POST /api/artwork/uploads (multipart/form-data) accepting logo and
watermark images. Validates content type (png/jpeg/gif/webp) and size
(SystemEnvironment.MaximumUploadMb, default 10MB) mirroring the Blazor
upload path; stores via IImageCache.SaveArtworkToCache; returns
{ path, contentType } consumable by channel create/update.

Includes handler + controller tests, OpenAPI 422 contract-test entry,
and regenerated v1.json.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

ErsatzTV.Application/Artworks/Commands/UploadArtwork.cs

@@ -0,0 +1,13 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Artworks;
+
+/// <summary>
+///     Validates and stores an uploaded image as channel logo or watermark artwork,
+///     landing it in the same on-disk cache the Blazor UI uses (via <c>IImageCache</c>),
+///     so the returned path is equivalent to a Blazor-uploaded image.
+/// </summary>
+public record UploadArtwork(Stream Stream, string ContentType, ArtworkKind ArtworkKind)
+    : IRequest<Either<BaseError, ArtworkUploadResponseModel>>;

ErsatzTV.Application/Artworks/Commands/UploadArtworkHandler.cs

@@ -0,0 +1,53 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Images;
+
+namespace ErsatzTV.Application.Artworks;
+
+public class UploadArtworkHandler : IRequestHandler<UploadArtwork, Either<BaseError, ArtworkUploadResponseModel>>
+{
+    // png/jpeg/gif/webp are all decoded by SkiaSharp and read by FFmpeg, matching the
+    // formats the Blazor logo/watermark upload already accepts. Format expansion is ersatztv#66.
+    private static readonly System.Collections.Generic.HashSet<string> AcceptedContentTypes = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "image/png",
+        "image/jpeg",
+        "image/gif",
+        "image/webp"
+    };
+
+    private readonly IImageCache _imageCache;
+
+    public UploadArtworkHandler(IImageCache imageCache) => _imageCache = imageCache;
+
+    public async Task<Either<BaseError, ArtworkUploadResponseModel>> Handle(
+        UploadArtwork request,
+        CancellationToken cancellationToken)
+    {
+        string contentType = (request.ContentType ?? string.Empty).Trim();
+        if (!AcceptedContentTypes.Contains(contentType))
+        {
+            return BaseError.New(
+                $"Unsupported image content type '{contentType}'; supported types are: {string.Join(", ", AcceptedContentTypes)}");
+        }
+
+        Either<BaseError, string> maybeFileName = await _imageCache.SaveArtworkToCache(
+            request.Stream,
+            request.ArtworkKind);
+
+        return maybeFileName.Map(fileName => new ArtworkUploadResponseModel(
+            BuildPath(request.ArtworkKind, fileName),
+            contentType));
+    }
+
+    // Mirror the on-disk conventions the Blazor editors use so the returned path is a drop-in
+    // for ArtworkContentTypeModel.Path: channel logos are addressed as "iptv/logos/{file}"
+    // (see ChannelEditor.UploadLogo), watermarks by the bare cache file name (see WatermarkEditor).
+    private static string BuildPath(ArtworkKind artworkKind, string fileName) =>
+        artworkKind switch
+        {
+            ArtworkKind.Logo => $"iptv/logos/{fileName}",
+            _ => fileName
+        };
+}

ErsatzTV.Application/Libraries/Queries/GetLibraryScanStatus.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Libraries;
+
+namespace ErsatzTV.Application.Libraries;
+
+public record GetLibraryScanStatus : IRequest<List<LibraryScanStatusResponseModel>>;

ErsatzTV.Application/Libraries/Queries/GetLibraryScanStatusHandler.cs

@@ -0,0 +1,20 @@
+using ErsatzTV.Core.Api.Libraries;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Metadata;
+
+namespace ErsatzTV.Application.Libraries;
+
+public class GetLibraryScanStatusHandler(IScannerProxyService scannerProxyService)
+    : IRequestHandler<GetLibraryScanStatus, List<LibraryScanStatusResponseModel>>
+{
+    public Task<List<LibraryScanStatusResponseModel>> Handle(
+        GetLibraryScanStatus request,
+        CancellationToken cancellationToken)
+    {
+        List<LibraryScanStatusResponseModel> result = scannerProxyService.GetActiveScans()
+            .Select(scan => new LibraryScanStatusResponseModel(scan.LibraryId, scan.Progress))
+            .ToList();
+
+        return Task.FromResult(result);
+    }
+}

ErsatzTV.Application/MediaSources/Queries/GetAllMediaSourcesForApi.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.MediaSources;
+
+namespace ErsatzTV.Application.MediaSources;
+
+public record GetAllMediaSourcesForApi : IRequest<List<MediaSourceResponseModel>>;

ErsatzTV.Application/MediaSources/Queries/GetAllMediaSourcesForApiHandler.cs

@@ -0,0 +1,148 @@
+#nullable enable
+using Dapper;
+using ErsatzTV.Core.Api.MediaSources;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaSources;
+
+public class GetAllMediaSourcesForApiHandler(
+    IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllMediaSourcesForApi, List<MediaSourceResponseModel>>
+{
+    public async Task<List<MediaSourceResponseModel>> Handle(
+        GetAllMediaSourcesForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<MediaSource> mediaSources = await dbContext.MediaSources
+                .AsNoTracking()
+                .Include(s => s.Libraries)
+                .ThenInclude(l => l.Paths)
+                .ToListAsync(cancellationToken);
+
+        Dictionary<int, int> itemCountsByLibrary = await GetItemCountsByLibrary(dbContext, cancellationToken);
+        Dictionary<int, string> addressByMediaSourceId = await GetConnectionAddresses(dbContext, cancellationToken);
+
+        var result = new List<MediaSourceResponseModel>();
+        foreach (MediaSource mediaSource in mediaSources)
+        {
+            List<MediaSourceLibraryResponseModel> libraryModels = mediaSource.Libraries
+                .Filter(ShouldIncludeLibrary)
+                .OrderBy(l => l.MediaKind)
+                .ThenBy(l => l.Name)
+                .Map(l => new MediaSourceLibraryResponseModel(
+                    l.Id,
+                    l.Name,
+                    l.MediaKind,
+                    l.LastScan,
+                    itemCountsByLibrary.TryGetValue(l.Id, out int count) ? count : 0))
+                .ToList();
+
+            string? address = addressByMediaSourceId.TryGetValue(mediaSource.Id, out string? a) ? a : null;
+
+            result.Add(
+                new MediaSourceResponseModel(
+                    mediaSource.Id,
+                    GetKind(mediaSource),
+                    GetName(mediaSource),
+                    address,
+                    libraryModels));
+        }
+
+        return result
+            .OrderBy(s => s.Kind == "Local" ? 0 : 1)
+            .ThenBy(s => s.Kind)
+            .ThenBy(s => s.Name)
+            .ToList();
+    }
+
+    private static async Task<Dictionary<int, int>> GetItemCountsByLibrary(
+        TvContext dbContext,
+        CancellationToken cancellationToken)
+    {
+        IEnumerable<LibraryItemCount> counts = await dbContext.Connection.QueryAsync<LibraryItemCount>(
+            new CommandDefinition(
+                @"SELECT LP.LibraryId AS LibraryId, COUNT(*) AS Count
+                      FROM MediaItem
+                      INNER JOIN LibraryPath LP on MediaItem.LibraryPathId = LP.Id
+                      GROUP BY LP.LibraryId",
+                cancellationToken: cancellationToken));
+
+        return counts.ToDictionary(c => (int)c.LibraryId, c => (int)c.Count);
+    }
+
+    private static async Task<Dictionary<int, string>> GetConnectionAddresses(
+        TvContext dbContext,
+        CancellationToken cancellationToken)
+    {
+        var addresses = new Dictionary<int, string>();
+
+        foreach (PlexMediaSource plex in await dbContext.PlexMediaSources
+                     .AsNoTracking()
+                     .Include(s => s.Connections)
+                     .ToListAsync(cancellationToken))
+        {
+            foreach (PlexConnection connection in Optional(plex.Connections.SingleOrDefault(c => c.IsActive)))
+            {
+                addresses[plex.Id] = connection.Uri;
+            }
+        }
+
+        foreach (JellyfinMediaSource jellyfin in await dbContext.JellyfinMediaSources
+                     .AsNoTracking()
+                     .Include(s => s.Connections)
+                     .ToListAsync(cancellationToken))
+        {
+            foreach (JellyfinConnection connection in jellyfin.Connections.HeadOrNone())
+            {
+                addresses[jellyfin.Id] = connection.Address;
+            }
+        }
+
+        foreach (EmbyMediaSource emby in await dbContext.EmbyMediaSources
+                     .AsNoTracking()
+                     .Include(s => s.Connections)
+                     .ToListAsync(cancellationToken))
+        {
+            foreach (EmbyConnection connection in emby.Connections.HeadOrNone())
+            {
+                addresses[emby.Id] = connection.Address;
+            }
+        }
+
+        return addresses;
+    }
+
+    private static bool ShouldIncludeLibrary(Library library) =>
+        library switch
+        {
+            LocalLibrary => library.Paths.Count > 0,
+            PlexLibrary plex => plex.ShouldSyncItems,
+            JellyfinLibrary jellyfin => jellyfin.ShouldSyncItems,
+            EmbyLibrary emby => emby.ShouldSyncItems,
+            _ => false
+        };
+
+    private static string GetKind(MediaSource mediaSource) =>
+        mediaSource switch
+        {
+            PlexMediaSource => "Plex",
+            JellyfinMediaSource => "Jellyfin",
+            EmbyMediaSource => "Emby",
+            _ => "Local"
+        };
+
+    private static string GetName(MediaSource mediaSource) =>
+        mediaSource switch
+        {
+            PlexMediaSource plex => plex.ServerName,
+            JellyfinMediaSource jellyfin => jellyfin.ServerName,
+            EmbyMediaSource emby => emby.ServerName,
+            _ => "Local"
+        };
+
+    private sealed record LibraryItemCount(long LibraryId, long Count);
+}

ErsatzTV.Core/Api/Artwork/ArtworkUploadResponseModel.cs

@@ -0,0 +1,10 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Artwork;
+
+/// <summary>
+///     Result of uploading channel logo / watermark artwork via the REST API.
+///     <see cref="Path" /> is directly consumable as the <c>Path</c> of an
+///     <c>ArtworkContentTypeModel</c> (e.g. <c>CreateChannel.Logo</c> / channel update),
+///     and <see cref="ContentType" /> carries the stored MIME type.
+/// </summary>
+public record ArtworkUploadResponseModel(string Path, string ContentType);

ErsatzTV.Core/Api/Libraries/LibraryScanStatusResponseModel.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Core.Api.Libraries;
+
+public record LibraryScanStatusResponseModel(int LibraryId, decimal Percent);

ErsatzTV.Core/Api/MediaSources/MediaSourceLibraryResponseModel.cs

@@ -0,0 +1,11 @@
+#nullable enable
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Core.Api.MediaSources;
+
+public record MediaSourceLibraryResponseModel(
+    int Id,
+    string Name,
+    LibraryMediaKind MediaKind,
+    DateTime? LastScan,
+    int ItemCount);

ErsatzTV.Core/Api/MediaSources/MediaSourceResponseModel.cs

@@ -0,0 +1,9 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.MediaSources;
+
+public record MediaSourceResponseModel(
+    int Id,
+    string Kind,
+    string Name,
+    string? ConnectionAddress,
+    List<MediaSourceLibraryResponseModel> Libraries);

ErsatzTV.Core/Interfaces/Metadata/IScannerProxyService.cs

@@ -1,3 +1,5 @@
+using ErsatzTV.Core.Metadata;
+
 namespace ErsatzTV.Core.Interfaces.Metadata;
 
 public interface IScannerProxyService
@@ -7,4 +9,5 @@ public interface IScannerProxyService
     Task Progress(Guid scanId, decimal percentComplete);
     bool IsActive(Guid scanId);
     Option<decimal> GetProgress(int libraryId);
+    IReadOnlyList<LibraryScanProgress> GetActiveScans();
 }

ErsatzTV.Core/Metadata/ScannerProxyService.cs

@@ -49,4 +49,7 @@ public class ScannerProxyService(IMediator mediator) : IScannerProxyService
     public Option<decimal> GetProgress(int libraryId) => _activeLibraries.TryGetValue(libraryId, out decimal progress)
         ? progress
         : Option<decimal>.None;
+
+    public IReadOnlyList<LibraryScanProgress> GetActiveScans() =>
+        _activeLibraries.Select(kvp => new LibraryScanProgress(kvp.Key, kvp.Value)).ToList();
 }

ErsatzTV.Tests/Application/Artworks/UploadArtworkHandlerTests.cs

@@ -0,0 +1,87 @@
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Images;
+using LanguageExt;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Tests.Application.Artworks;
+
+[TestFixture]
+public class UploadArtworkHandlerTests
+{
+    private IImageCache _imageCache = null!;
+    private UploadArtworkHandler _handler = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _imageCache = Substitute.For<IImageCache>();
+        _handler = new UploadArtworkHandler(_imageCache);
+    }
+
+    [Test]
+    public async Task Handle_Should_Return_Logo_Path_With_Iptv_Logos_Prefix()
+    {
+        _imageCache.SaveArtworkToCache(Arg.Any<Stream>(), ArtworkKind.Logo)
+            .Returns(Right<BaseError, string>("abc123.png"));
+
+        using var stream = new MemoryStream();
+        Either<BaseError, ArtworkUploadResponseModel> result =
+            await _handler.Handle(new UploadArtwork(stream, "image/png", ArtworkKind.Logo), CancellationToken.None);
+
+        ArtworkUploadResponseModel response = RightOf(result);
+        response.Path.ShouldBe("iptv/logos/abc123.png");
+        response.ContentType.ShouldBe("image/png");
+    }
+
+    [Test]
+    public async Task Handle_Should_Return_Bare_File_Name_For_Watermark()
+    {
+        _imageCache.SaveArtworkToCache(Arg.Any<Stream>(), ArtworkKind.Watermark)
+            .Returns(Right<BaseError, string>("def456.webp"));
+
+        using var stream = new MemoryStream();
+        Either<BaseError, ArtworkUploadResponseModel> result = await _handler.Handle(
+            new UploadArtwork(stream, "image/webp", ArtworkKind.Watermark),
+            CancellationToken.None);
+
+        RightOf(result).Path.ShouldBe("def456.webp");
+    }
+
+    [Test]
+    public async Task Handle_Should_Reject_Unsupported_Content_Type()
+    {
+        using var stream = new MemoryStream();
+        Either<BaseError, ArtworkUploadResponseModel> result = await _handler.Handle(
+            new UploadArtwork(stream, "image/bmp", ArtworkKind.Logo),
+            CancellationToken.None);
+
+        LeftOf(result).Value.ShouldContain("Unsupported image content type");
+        await _imageCache.DidNotReceive().SaveArtworkToCache(Arg.Any<Stream>(), Arg.Any<ArtworkKind>());
+    }
+
+    [Test]
+    public async Task Handle_Should_Propagate_Cache_Save_Failure()
+    {
+        _imageCache.SaveArtworkToCache(Arg.Any<Stream>(), ArtworkKind.Logo)
+            .Returns(Left<BaseError, string>(BaseError.New("disk full")));
+
+        using var stream = new MemoryStream();
+        Either<BaseError, ArtworkUploadResponseModel> result = await _handler.Handle(
+            new UploadArtwork(stream, "image/png", ArtworkKind.Logo),
+            CancellationToken.None);
+
+        LeftOf(result).Value.ShouldBe("disk full");
+    }
+
+    private static TR RightOf<TR>(Either<BaseError, TR> either) =>
+        either.Match(Right: v => v, Left: e => throw new AssertionException($"Expected Right, got Left: {e.Value}"));
+
+    private static BaseError LeftOf<TR>(Either<BaseError, TR> either) =>
+        either.Match(Right: _ => throw new AssertionException("Expected Left, got Right"), Left: e => e);
+}

ErsatzTV.Tests/Application/Libraries/GetLibraryScanStatusHandlerTests.cs

@@ -0,0 +1,32 @@
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core.Api.Libraries;
+using ErsatzTV.Core.Metadata;
+using MediatR;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.Libraries;
+
+[TestFixture]
+public class GetLibraryScanStatusHandlerTests
+{
+    [Test]
+    public async Task Handle_Should_Return_Active_Scans()
+    {
+        var mediator = Substitute.For<IMediator>();
+        var scannerProxyService = new ScannerProxyService(mediator);
+        Guid scanId = scannerProxyService.StartScan(42)
+            .Match(
+                Some: id => id,
+                None: () => throw new AssertionException("Expected scan to start"));
+        await scannerProxyService.Progress(scanId, 62.5m);
+
+        var handler = new GetLibraryScanStatusHandler(scannerProxyService);
+
+        List<LibraryScanStatusResponseModel> result =
+            await handler.Handle(new GetLibraryScanStatus(), CancellationToken.None);
+
+        result.ShouldBe([new LibraryScanStatusResponseModel(42, 62.5m)]);
+    }
+}

ErsatzTV.Tests/Application/MediaSources/GetAllMediaSourcesForApiHandlerTests.cs

@@ -0,0 +1,179 @@
+using ErsatzTV.Application.MediaSources;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.MediaSources;
+
+[TestFixture]
+public class GetAllMediaSourcesForApiHandlerTests
+{
+    private InMemoryTvContext _db = null!;
+
+    [SetUp]
+    public async Task SetUp() => _db = await InMemoryTvContext.CreateAsync();
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    [Test]
+    public async Task Handle_Should_Group_Configured_Libraries_By_Source_With_Item_Counts()
+    {
+        await SeedMediaSources();
+        var handler = new GetAllMediaSourcesForApiHandler(_db.Factory);
+
+        var result = await handler.Handle(new GetAllMediaSourcesForApi(), CancellationToken.None);
+
+        result.Count.ShouldBe(4);
+
+        result[0].Kind.ShouldBe("Local");
+        result[0].Name.ShouldBe("Local");
+        result[0].ConnectionAddress.ShouldBeNull();
+        result[0].Libraries.Single().Name.ShouldBe("Local Movies");
+        result[0].Libraries.Single().LastScan.ShouldBe(new DateTime(2026, 7, 1, 0, 0, 0, DateTimeKind.Utc));
+        result[0].Libraries.Single().ItemCount.ShouldBe(2);
+
+        result[1].Kind.ShouldBe("Emby");
+        result[1].Name.ShouldBe("Emby Server");
+        result[1].ConnectionAddress.ShouldBe("http://emby.local");
+        result[1].Libraries.Single().Name.ShouldBe("Emby Shows");
+        result[1].Libraries.Single().ItemCount.ShouldBe(1);
+
+        result[2].Kind.ShouldBe("Jellyfin");
+        result[2].Name.ShouldBe("Jellyfin Server");
+        result[2].ConnectionAddress.ShouldBe("http://jellyfin.local");
+        result[2].Libraries.ShouldBeEmpty();
+
+        result[3].Kind.ShouldBe("Plex");
+        result[3].Name.ShouldBe("Plex Server");
+        result[3].ConnectionAddress.ShouldBe("http://plex.local");
+        result[3].Libraries.Single().Name.ShouldBe("Plex Movies");
+        result[3].Libraries.Single().ItemCount.ShouldBe(0);
+    }
+
+    [Test]
+    public async Task Handle_Should_Exclude_Unconfigured_And_Not_Synced_Libraries()
+    {
+        await SeedMediaSources();
+        var handler = new GetAllMediaSourcesForApiHandler(_db.Factory);
+
+        var result = await handler.Handle(new GetAllMediaSourcesForApi(), CancellationToken.None);
+
+        result.SelectMany(s => s.Libraries).Select(l => l.Name)
+            .ShouldNotContain("Empty Local");
+        result.SelectMany(s => s.Libraries).Select(l => l.Name)
+            .ShouldNotContain("Disabled Jellyfin");
+    }
+
+    private async Task SeedMediaSources()
+    {
+        await using TvContext context = _db.CreateContext();
+
+        var localSource = new LocalMediaSource
+        {
+            Libraries =
+            [
+                new LocalLibrary
+                {
+                    Name = "Local Movies",
+                    MediaKind = LibraryMediaKind.Movies,
+                    LastScan = new DateTime(2026, 7, 1, 0, 0, 0, DateTimeKind.Utc),
+                    Paths = [MakePath("/media/movies", 2)]
+                },
+                new LocalLibrary
+                {
+                    Name = "Empty Local",
+                    MediaKind = LibraryMediaKind.Shows,
+                    Paths = []
+                }
+            ]
+        };
+
+        var plexSource = new PlexMediaSource
+        {
+            ServerName = "Plex Server",
+            ProductVersion = "1",
+            Platform = "Linux",
+            PlatformVersion = "1",
+            ClientIdentifier = "plex",
+            Connections = [new PlexConnection { IsActive = true, Uri = "http://plex.local" }],
+            PathReplacements = [],
+            Libraries =
+            [
+                new PlexLibrary
+                {
+                    Name = "Plex Movies",
+                    MediaKind = LibraryMediaKind.Movies,
+                    Key = "1",
+                    ShouldSyncItems = true,
+                    Paths = []
+                }
+            ]
+        };
+
+        var embySource = new EmbyMediaSource
+        {
+            ServerName = "Emby Server",
+            OperatingSystem = "Linux",
+            Connections = [new EmbyConnection { Address = "http://emby.local" }],
+            PathReplacements = [],
+            Libraries =
+            [
+                new EmbyLibrary
+                {
+                    Name = "Emby Shows",
+                    MediaKind = LibraryMediaKind.Shows,
+                    ItemId = "emby-shows",
+                    ShouldSyncItems = true,
+                    PathInfos = [],
+                    Paths = [MakePath("/emby/shows", 1)]
+                }
+            ]
+        };
+
+        var jellyfinSource = new JellyfinMediaSource
+        {
+            ServerName = "Jellyfin Server",
+            OperatingSystem = "Linux",
+            Connections = [new JellyfinConnection { Address = "http://jellyfin.local" }],
+            PathReplacements = [],
+            Libraries =
+            [
+                new JellyfinLibrary
+                {
+                    Name = "Disabled Jellyfin",
+                    MediaKind = LibraryMediaKind.Movies,
+                    ItemId = "jellyfin-movies",
+                    ShouldSyncItems = false,
+                    PathInfos = [],
+                    Paths = [MakePath("/jellyfin/movies", 1)]
+                }
+            ]
+        };
+
+        context.MediaSources.AddRange(localSource, plexSource, embySource, jellyfinSource);
+        await context.SaveChangesAsync();
+        context.ChangeTracker.Clear();
+    }
+
+    private static LibraryPath MakePath(string path, int mediaItemCount) =>
+        new()
+        {
+            Path = path,
+            LibraryFolders = [],
+            MediaItems = Enumerable.Range(0, mediaItemCount)
+                .Select(_ => new Movie
+                {
+                    MovieMetadata = [],
+                    MediaVersions = [],
+                    Collections = [],
+                    CollectionItems = [],
+                    TraktListItems = []
+                })
+                .Cast<MediaItem>()
+                .ToList()
+        };
+}

ErsatzTV.Tests/Controllers/ArtworkUploadControllerTests.cs

@@ -0,0 +1,164 @@
+using System.Reflection;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class ArtworkUploadControllerTests
+{
+    private ArtworkUploadController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new ArtworkUploadController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Route()
+    {
+        MethodInfo action = typeof(ArtworkUploadController).GetMethod(nameof(ArtworkUploadController.Upload))
+            ?? throw new AssertionException("Missing action Upload");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain("POST");
+        attribute.Template.ShouldBe("/api/artwork/uploads");
+        attribute.Name.ShouldBe("UploadArtwork");
+    }
+
+    [Test]
+    public void Action_Should_Consume_Multipart_Form_Data()
+    {
+        MethodInfo action = typeof(ArtworkUploadController).GetMethod(nameof(ArtworkUploadController.Upload))
+            ?? throw new AssertionException("Missing action Upload");
+
+        var consumes = action.GetCustomAttribute<ConsumesAttribute>();
+        consumes.ShouldNotBeNull();
+        consumes.ContentTypes.ShouldContain("multipart/form-data");
+    }
+
+    [Test]
+    public async Task Upload_Should_Return_422_When_File_Missing()
+    {
+        IActionResult result = await _controller.Upload(null!, "logo", CancellationToken.None);
+
+        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        var problem = unprocessable.Value.ShouldBeOfType<ProblemDetails>();
+        problem.Status.ShouldBe(422);
+        problem.Title.ShouldBe("Validation failed");
+        await _mediator.DidNotReceive().Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Return_422_When_File_Empty()
+    {
+        IFormFile emptyFile = MakeFormFile([], "image/png");
+
+        IActionResult result = await _controller.Upload(emptyFile, "logo", CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Return_422_When_File_Exceeds_Maximum_Size()
+    {
+        var oversizeBytes = new byte[(SystemEnvironment.MaximumUploadMb * 1024 * 1024) + 1];
+        IFormFile oversizeFile = MakeFormFile(oversizeBytes, "image/png");
+
+        IActionResult result = await _controller.Upload(oversizeFile, "logo", CancellationToken.None);
+
+        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        var problem = unprocessable.Value.ShouldBeOfType<ProblemDetails>();
+        problem.Detail.ShouldContain("maximum allowed size");
+        await _mediator.DidNotReceive().Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Return_422_For_Unknown_Target()
+    {
+        IFormFile file = MakeFormFile([1, 2, 3], "image/png");
+
+        IActionResult result = await _controller.Upload(file, "poster", CancellationToken.None);
+
+        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        var problem = unprocessable.Value.ShouldBeOfType<ProblemDetails>();
+        problem.Detail.ShouldContain("Unknown upload target");
+        await _mediator.DidNotReceive().Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Send_UploadArtwork_With_Logo_Kind_And_Return_201()
+    {
+        IFormFile file = MakeFormFile([1, 2, 3], "image/png");
+        _mediator.Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, ArtworkUploadResponseModel>(
+                new ArtworkUploadResponseModel("iptv/logos/abc.png", "image/png")));
+
+        IActionResult result = await _controller.Upload(file, "logo", CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.StatusCode.ShouldBe(201);
+        created.Location.ShouldBe("/iptv/logos/abc.png?contentType=image%2Fpng");
+        created.Value.ShouldBeOfType<ArtworkUploadResponseModel>()
+            .Path.ShouldBe("iptv/logos/abc.png");
+
+        await _mediator.Received(1).Send(
+            Arg.Is<UploadArtwork>(c => c.ArtworkKind == ArtworkKind.Logo && c.ContentType == "image/png"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Send_UploadArtwork_With_Watermark_Kind_And_Return_201()
+    {
+        IFormFile file = MakeFormFile([1, 2, 3], "image/webp");
+        _mediator.Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, ArtworkUploadResponseModel>(
+                new ArtworkUploadResponseModel("def.webp", "image/webp")));
+
+        IActionResult result = await _controller.Upload(file, "watermark", CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/artwork/watermarks/def.webp?contentType=image%2Fwebp");
+
+        await _mediator.Received(1).Send(
+            Arg.Is<UploadArtwork>(c => c.ArtworkKind == ArtworkKind.Watermark),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Return_422_On_Handler_Validation_Error()
+    {
+        IFormFile file = MakeFormFile([1, 2, 3], "image/bmp");
+        _mediator.Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, ArtworkUploadResponseModel>(BaseError.New("unsupported content type")));
+
+        IActionResult result = await _controller.Upload(file, "logo", CancellationToken.None);
+
+        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        var problem = unprocessable.Value.ShouldBeOfType<ProblemDetails>();
+        problem.Status.ShouldBe(422);
+        problem.Title.ShouldBe("Validation failed");
+    }
+
+    private static IFormFile MakeFormFile(byte[] bytes, string contentType) =>
+        new FormFile(new MemoryStream(bytes), 0, bytes.Length, "file", "upload.bin")
+        {
+            Headers = new HeaderDictionary(),
+            ContentType = contentType
+        };
+}

ErsatzTV.Tests/Controllers/LibrariesControllerTests.cs

@@ -0,0 +1,55 @@
+using System.Reflection;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core.Api.Libraries;
+using ErsatzTV.Core.Interfaces.Repositories;
+using MediatR;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class LibrariesControllerTests
+{
+    private LibrariesController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new LibrariesController(Substitute.For<ITelevisionRepository>(), _mediator);
+    }
+
+    [Test]
+    public void ScanStatus_Should_Expose_Idiomatic_Rest_Route()
+    {
+        MethodInfo action = typeof(LibrariesController).GetMethod(nameof(LibrariesController.GetScanStatus))
+            ?? throw new AssertionException("Missing action GetScanStatus");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain("GET");
+        attribute.Template.ShouldBe("/api/libraries/scan-status");
+        attribute.Name.ShouldBe("GetLibraryScanStatus");
+    }
+
+    [Test]
+    public async Task GetScanStatus_Should_Return_Results_From_Mediator()
+    {
+        var expected = new List<LibraryScanStatusResponseModel>
+        {
+            new(1, 42.5m),
+            new(2, 99m)
+        };
+
+        _mediator.Send(Arg.Any<GetLibraryScanStatus>(), Arg.Any<CancellationToken>())
+            .Returns(expected);
+
+        List<LibraryScanStatusResponseModel> result = await _controller.GetScanStatus(CancellationToken.None);
+
+        result.ShouldBe(expected);
+    }
+}

ErsatzTV.Tests/Controllers/MediaSourcesControllerTests.cs

@@ -0,0 +1,59 @@
+using System.Reflection;
+using ErsatzTV.Application.MediaSources;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core.Api.MediaSources;
+using ErsatzTV.Core.Domain;
+using MediatR;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class MediaSourcesControllerTests
+{
+    private MediaSourcesController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new MediaSourcesController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Route()
+    {
+        MethodInfo action = typeof(MediaSourcesController).GetMethod(nameof(MediaSourcesController.GetAll))
+            ?? throw new AssertionException("Missing action GetAll");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain("GET");
+        attribute.Template.ShouldBe("/api/media-sources");
+        attribute.Name.ShouldBe("GetMediaSources");
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_Results_From_Mediator()
+    {
+        var expected = new List<MediaSourceResponseModel>
+        {
+            new(
+                1,
+                "Local",
+                "Local",
+                null,
+                [new MediaSourceLibraryResponseModel(10, "Movies", LibraryMediaKind.Movies, null, 3)])
+        };
+
+        _mediator.Send(Arg.Any<GetAllMediaSourcesForApi>(), Arg.Any<CancellationToken>())
+            .Returns(expected);
+
+        List<MediaSourceResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBe(expected);
+    }
+}

ErsatzTV.Tests/Controllers/OpenApiErrorResponseContractTests.cs

@@ -69,6 +69,7 @@ public class OpenApiErrorResponseContractTests
     [TestCase("/api/playouts/{id}", "delete", "404")]
     [TestCase("/api/playouts/{id}", "delete", "422")]
     [TestCase("/api/playouts/{id}/items", "get", "404")]
+    [TestCase("/api/artwork/uploads", "post", "422")]
     [TestCase("/api/ffmpeg/profiles/{id}", "get", "404")]
     [TestCase("/api/ffmpeg/profiles", "post", "404")]
     [TestCase("/api/ffmpeg/profiles", "post", "401")]

ErsatzTV/Controllers/Api/ArtworkUploadController.cs

@@ -0,0 +1,85 @@
+using System.ComponentModel;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Extensions;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class ArtworkUploadController(IMediator mediator) : ControllerBase
+{
+    [HttpPost("/api/artwork/uploads", Name = "UploadArtwork")]
+    [Consumes("multipart/form-data")]
+    [Tags("Artwork")]
+    [EndpointSummary("Upload channel logo or watermark artwork")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(ArtworkUploadResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Upload(
+        IFormFile file,
+        [FromForm] [Description("Artwork target: 'logo' (default) or 'watermark'")] string target,
+        CancellationToken cancellationToken)
+    {
+        if (file is null || file.Length == 0)
+        {
+            return BaseError.New("A non-empty image file is required").ToErrorResult();
+        }
+
+        long maxBytes = (long)SystemEnvironment.MaximumUploadMb * 1024 * 1024;
+        if (file.Length > maxBytes)
+        {
+            return BaseError.New($"Image exceeds the maximum allowed size of {SystemEnvironment.MaximumUploadMb} MB")
+                .ToErrorResult();
+        }
+
+        if (!TryParseTarget(target, out ArtworkKind artworkKind))
+        {
+            return BaseError.New($"Unknown upload target '{target}'; expected 'logo' or 'watermark'").ToErrorResult();
+        }
+
+        await using Stream stream = file.OpenReadStream();
+        Either<BaseError, ArtworkUploadResponseModel> result = await mediator.Send(
+            new UploadArtwork(stream, file.ContentType, artworkKind),
+            cancellationToken);
+
+        return result.ToCreatedResult(
+            value => LocationFor(artworkKind, value.Path, value.ContentType),
+            value => value);
+    }
+
+    // "logo" (default) and "watermark" are the two channel-artwork surfaces the API exposes today.
+    private static bool TryParseTarget(string target, out ArtworkKind artworkKind)
+    {
+        switch ((target ?? string.Empty).Trim().ToLowerInvariant())
+        {
+            case "":
+            case "logo":
+                artworkKind = ArtworkKind.Logo;
+                return true;
+            case "watermark":
+                artworkKind = ArtworkKind.Watermark;
+                return true;
+            default:
+                artworkKind = ArtworkKind.Logo;
+                return false;
+        }
+    }
+
+    // Both GetImage (IptvController) and GetWatermark (ArtworkController) require a contentType
+    // query param to serve the cached file, so the Location header must carry it too.
+    private static string LocationFor(ArtworkKind artworkKind, string path, string contentType)
+    {
+        string encodedContentType = Uri.EscapeDataString(contentType);
+        return artworkKind switch
+        {
+            // logo paths already carry the servable prefix ("iptv/logos/{file}")
+            ArtworkKind.Logo => $"/{path}?contentType={encodedContentType}",
+            _ => $"/artwork/watermarks/{path}?contentType={encodedContentType}"
+        };
+    }
+}

ErsatzTV/Controllers/Api/LibrariesController.cs

@@ -1,14 +1,23 @@
 using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core.Api.Libraries;
 using ErsatzTV.Core.Interfaces.Repositories;
 using MediatR;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 
 namespace ErsatzTV.Controllers.Api;
 
 [ApiController]
 [EndpointGroupName("general")]
-public class LibrariesController(ITelevisionRepository televisionRepository, IMediator mediator)
+public class LibrariesController(ITelevisionRepository televisionRepository, IMediator mediator) : ControllerBase
 {
+    [HttpGet("/api/libraries/scan-status", Name = "GetLibraryScanStatus")]
+    [Tags("Libraries")]
+    [EndpointSummary("Get active library scan status")]
+    [ProducesResponseType(typeof(List<LibraryScanStatusResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<LibraryScanStatusResponseModel>> GetScanStatus(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetLibraryScanStatus(), cancellationToken);
+
     [HttpPost("/api/libraries/{id:int}/scan")]
     [Tags("Libraries")]
     [EndpointSummary("Scan library")]

ErsatzTV/Controllers/Api/MediaSourcesController.cs

@@ -0,0 +1,19 @@
+using ErsatzTV.Application.MediaSources;
+using ErsatzTV.Core.Api.MediaSources;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class MediaSourcesController(IMediator mediator) : ControllerBase
+{
+    [HttpGet("/api/media-sources", Name = "GetMediaSources")]
+    [Tags("Media Sources")]
+    [EndpointSummary("Get all media sources with their libraries")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<MediaSourceResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<MediaSourceResponseModel>> GetAll(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetAllMediaSourcesForApi(), cancellationToken);
+}

ErsatzTV/wwwroot/openapi/v1.json

@@ -5,6 +5,85 @@
     "version": "1.0.0"
   },
   "paths": {
+    "/api/artwork/uploads": {
+      "post": {
+        "tags": [
+          "Artwork"
+        ],
+        "summary": "Upload channel logo or watermark artwork",
+        "operationId": "UploadArtwork",
+        "requestBody": {
+          "content": {
+            "multipart/form-data": {
+              "schema": {
+                "type": "object",
+                "allOf": [
+                  {
+                    "type": "object",
+                    "properties": {
+                      "file": {
+                        "$ref": "#/components/schemas/IFormFile"
+                      }
+                    }
+                  },
+                  {
+                    "type": "object",
+                    "properties": {
+                      "target": {
+                        "type": "string"
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "201": {
+            "description": "Created",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ArtworkUploadResponseModel"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ArtworkUploadResponseModel"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ArtworkUploadResponseModel"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Unprocessable Entity",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/api/channels": {
       "get": {
         "tags": [
@@ -1481,6 +1560,46 @@
         }
       }
     },
+    "/api/libraries/scan-status": {
+      "get": {
+        "tags": [
+          "Libraries"
+        ],
+        "summary": "Get active library scan status",
+        "operationId": "GetLibraryScanStatus",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/LibraryScanStatusResponseModel"
+                  }
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/LibraryScanStatusResponseModel"
+                  }
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/LibraryScanStatusResponseModel"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/api/libraries/{id}/scan": {
       "post": {
         "tags": [
@@ -1603,6 +1722,46 @@
         }
       }
     },
+    "/api/media-sources": {
+      "get": {
+        "tags": [
+          "Media Sources"
+        ],
+        "summary": "Get all media sources with their libraries",
+        "operationId": "GetMediaSources",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/MediaSourceResponseModel"
+                  }
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/MediaSourceResponseModel"
+                  }
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/MediaSourceResponseModel"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/api/playouts": {
       "get": {
         "tags": [
@@ -3421,6 +3580,21 @@
           }
         }
       },
+      "ArtworkUploadResponseModel": {
+        "required": [
+          "path",
+          "contentType"
+        ],
+        "type": "object",
+        "properties": {
+          "path": {
+            "type": "string"
+          },
+          "contentType": {
+            "type": "string"
+          }
+        }
+      },
       "ChannelIdleBehavior": {
         "enum": [
           "StopOnDisconnect",
@@ -4647,6 +4821,39 @@
           }
         }
       },
+      "IFormFile": {
+        "type": "string",
+        "format": "binary"
+      },
+      "LibraryMediaKind": {
+        "enum": [
+          "Movies",
+          "Shows",
+          "MusicVideos",
+          "OtherVideos",
+          "Songs",
+          "Images",
+          "RemoteStreams"
+        ],
+        "type": "string"
+      },
+      "LibraryScanStatusResponseModel": {
+        "required": [
+          "libraryId",
+          "percent"
+        ],
+        "type": "object",
+        "properties": {
+          "libraryId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "percent": {
+            "type": "number",
+            "format": "double"
+          }
+        }
+      },
       "MarathonGroupBy": {
         "enum": [
           "None",
@@ -4729,6 +4936,73 @@
         ],
         "type": "string"
       },
+      "MediaSourceLibraryResponseModel": {
+        "required": [
+          "id",
+          "name",
+          "mediaKind",
+          "lastScan",
+          "itemCount"
+        ],
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "name": {
+            "type": "string"
+          },
+          "mediaKind": {
+            "$ref": "#/components/schemas/LibraryMediaKind"
+          },
+          "lastScan": {
+            "type": [
+              "null",
+              "string"
+            ],
+            "format": "date-time"
+          },
+          "itemCount": {
+            "type": "integer",
+            "format": "int32"
+          }
+        }
+      },
+      "MediaSourceResponseModel": {
+        "required": [
+          "id",
+          "kind",
+          "name",
+          "connectionAddress",
+          "libraries"
+        ],
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "kind": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          },
+          "connectionAddress": {
+            "type": [
+              "null",
+              "string"
+            ]
+          },
+          "libraries": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/MediaSourceLibraryResponseModel"
+            }
+          }
+        }
+      },
       "MultiCollectionItemViewModel": {
         "required": [
           "multiCollectionId",
@@ -6361,6 +6635,9 @@
     }
   },
   "tags": [
+    {
+      "name": "Artwork"
+    },
     {
       "name": "Channel"
     },
@@ -6388,6 +6665,9 @@
     {
       "name": "Maintenance"
     },
+    {
+      "name": "Media Sources"
+    },
     {
       "name": "Playouts"
     },