diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0d771c70c..9e26f3ff8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,7 +16,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 - Add `sub_language` and `sub_language_tag` fields to search index
 - Add `/iptv` request logging in its own log category at debug level
 - Add channel guide (XMLTV) template system
-    - Templates should be copied from `_channel.sbntxt`, `_movie.sbntxt`, `_episode.sbntxt`, or `_musicVideo.sbntxt` which are located in the config subfolder `templates/channel-guide`
+    - Templates should be copied from `_channel.sbntxt`, `_movie.sbntxt`, `_episode.sbntxt`, `_musicVideo.sbntxt`, `_song.sbntxt`, or `_otherVideo.sbntxt` which are located in the config subfolder `templates/channel-guide`
         - Copy the file, remove the leading underscore from the name, and only make edits to the copied file
     - The default templates will be extracted and overwritten every time ErsatzTV is started
     - The templates use [scribian](https://github.com/scriban/scriban/tree/master/doc) template syntax
@@ -35,6 +35,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
   - Previously, search index updates would slowly process over minutes/hours after library scans completed
   - Search index updates should now complete at the same time as library scans
 - Do not unnecessarily update the search index during media server library scans
+- Use different library for reading song metadata that supports multiple tag entries
 
 ## [0.8.5-beta] - 2024-01-30
 ### Added
diff --git a/ErsatzTV.Application/Channels/Commands/RefreshChannelDataHandler.cs b/ErsatzTV.Application/Channels/Commands/RefreshChannelDataHandler.cs
index 414767593..c29fa6fdf 100644
--- a/ErsatzTV.Application/Channels/Commands/RefreshChannelDataHandler.cs
+++ b/ErsatzTV.Application/Channels/Commands/RefreshChannelDataHandler.cs
@@ -44,11 +44,14 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         string movieTemplateFileName = GetMovieTemplateFileName();
         string episodeTemplateFileName = GetEpisodeTemplateFileName();
         string musicVideoTemplateFileName = GetMusicVideoTemplateFileName();
-        if (movieTemplateFileName is null || episodeTemplateFileName is null || musicVideoTemplateFileName is null)
+        string songTemplateFileName = GetSongTemplateFileName();
+        string otherVideoTemplateFileName = GetOtherVideoTemplateFileName();
+        if (movieTemplateFileName is null || episodeTemplateFileName is null || musicVideoTemplateFileName is null ||
+            songTemplateFileName is null || otherVideoTemplateFileName is null)
         {
             return;
         }
-        
+
         var minifier = new XmlMinifier(
             new XmlMinificationSettings
             {
@@ -68,6 +71,12 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         string musicVideoText = await File.ReadAllTextAsync(musicVideoTemplateFileName, cancellationToken);
         var musicVideoTemplate = Template.Parse(musicVideoText, musicVideoTemplateFileName);
 
+        string songText = await File.ReadAllTextAsync(songTemplateFileName, cancellationToken);
+        var songTemplate = Template.Parse(songText, songTemplateFileName);
+
+        string otherVideoText = await File.ReadAllTextAsync(otherVideoTemplateFileName, cancellationToken);
+        var otherVideoTemplate = Template.Parse(otherVideoText, otherVideoTemplateFileName);
+
         await using TvContext dbContext = await _dbContextFactory.CreateDbContextAsync(cancellationToken);
 
         List<Playout> playouts = await dbContext.Playouts
@@ -140,6 +149,14 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
             .ThenInclude(i => i.MediaItem)
             .ThenInclude(i => (i as Song).SongMetadata)
             .ThenInclude(vm => vm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(sm => sm.Studios)
             .ToListAsync(cancellationToken);
 
         List<PlayoutItem> sorted = [];
@@ -217,243 +234,353 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
             string title = GetTitle(displayItem);
             string subtitle = GetSubtitle(displayItem);
-            string description = GetDescription(displayItem);
-            Option<ContentRating> contentRating = GetContentRating(displayItem);
 
-            if (displayItem.MediaItem is Movie templateMovie)
+            Option<string> maybeTemplateOutput = displayItem.MediaItem switch
             {
-                foreach (MovieMetadata metadata in templateMovie.MovieMetadata.HeadOrNone())
-                {
-                    metadata.Genres ??= [];
-                    metadata.Guids ??= [];
-                    
-                    string poster = Optional(metadata.Artwork).Flatten()
-                        .Filter(a => a.ArtworkKind == ArtworkKind.Poster)
-                        .HeadOrNone()
-                        .Match(a => GetArtworkUrl(a, ArtworkKind.Poster), () => string.Empty);
-
-                    var data = new
-                    {
-                        ProgrammeStart = start,
-                        ProgrammeStop = stop,
-                        ChannelNumber = request.ChannelNumber,
-                        HasCustomTitle = hasCustomTitle,
-                        CustomTitle = displayItem.CustomTitle,
-                        MovieTitle = title,
-                        MovieHasPlot = !string.IsNullOrWhiteSpace(metadata.Plot),
-                        MoviePlot = metadata.Plot,
-                        MovieHasYear = metadata.Year.HasValue,
-                        MovieYear = metadata.Year,
-                        MovieGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
-                        MovieHasArtwork = !string.IsNullOrWhiteSpace(poster),
-                        MovieArtworkUrl = poster,
-                        MovieHasContentRating = !string.IsNullOrWhiteSpace(metadata.ContentRating),
-                        MovieContentRating = metadata.ContentRating,
-                        MovieGuids = metadata.Guids.Map(g => g.Guid)
-                    };
-
-                    var scriptObject = new ScriptObject();
-                    scriptObject.Import(data);
-                    templateContext.PushGlobal(scriptObject);
-
-                    string result = await movieTemplate.RenderAsync(templateContext);
-
-                    MarkupMinificationResult minified = minifier.Minify(result);
-                    await xml.WriteRawAsync(minified.MinifiedContent);
-                }
+                Movie templateMovie => await ProcessMovieTemplate(
+                    request,
+                    templateMovie,
+                    start,
+                    stop,
+                    hasCustomTitle,
+                    displayItem,
+                    title,
+                    templateContext,
+                    movieTemplate),
+                Episode templateEpisode => await ProcessEpisodeTemplate(
+                    request,
+                    templateEpisode,
+                    start,
+                    stop,
+                    hasCustomTitle,
+                    displayItem,
+                    title,
+                    subtitle,
+                    templateContext,
+                    episodeTemplate),
+                MusicVideo templateMusicVideo => await ProcessMusicVideoTemplate(
+                    request,
+                    templateMusicVideo,
+                    start,
+                    stop,
+                    hasCustomTitle,
+                    displayItem,
+                    title,
+                    subtitle,
+                    templateContext,
+                    musicVideoTemplate),
+                Song templateSong => await ProcessSongTemplate(
+                    request,
+                    templateSong,
+                    start,
+                    stop,
+                    hasCustomTitle,
+                    displayItem,
+                    title,
+                    subtitle,
+                    templateContext,
+                    songTemplate),
+                OtherVideo templateOtherVideo => await ProcessOtherVideoTemplate(
+                    request,
+                    templateOtherVideo,
+                    start,
+                    stop,
+                    hasCustomTitle,
+                    displayItem,
+                    title,
+                    templateContext,
+                    otherVideoTemplate),
+                _ => Option<string>.None
+            };
 
-                i++;
-                continue;
+            foreach (string templateOutput in maybeTemplateOutput)
+            {
+                MarkupMinificationResult minified = minifier.Minify(templateOutput);
+                await xml.WriteRawAsync(minified.MinifiedContent);
             }
 
-            if (displayItem.MediaItem is Episode templateEpisode)
-            {
-                foreach (EpisodeMetadata metadata in templateEpisode.EpisodeMetadata.HeadOrNone())
-                {
-                    metadata.Genres ??= [];
-                    metadata.Guids ??= [];
+            i++;
+        }
 
-                    foreach (ShowMetadata showMetadata in Optional(
-                                 templateEpisode.Season?.Show?.ShowMetadata.HeadOrNone()).Flatten())
-                    {
-                        showMetadata.Genres ??= [];
-                        showMetadata.Guids ??= [];
+        await xml.FlushAsync();
 
-                        string artworkPath = GetPrioritizedArtworkPath(metadata);
+        string tempFile = Path.GetTempFileName();
+        await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
 
-                        var data = new
-                        {
-                            ProgrammeStart = start,
-                            ProgrammeStop = stop,
-                            ChannelNumber = request.ChannelNumber,
-                            HasCustomTitle = hasCustomTitle,
-                            CustomTitle = displayItem.CustomTitle,
-                            ShowTitle = title,
-                            EpisodeHasTitle = !string.IsNullOrWhiteSpace(subtitle),
-                            EpisodeTitle = subtitle,
-                            EpisodeHasPlot = !string.IsNullOrWhiteSpace(metadata.Plot),
-                            EpisodePlot = metadata.Plot,
-                            ShowHasYear = showMetadata.Year.HasValue,
-                            ShowYear = showMetadata.Year,
-                            ShowGenres = showMetadata.Genres.Map(g => g.Name).OrderBy(n => n),
-                            EpisodeHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
-                            EpisodeArtworkUrl = artworkPath,
-                            SeasonNumber = templateEpisode.Season?.SeasonNumber ?? 0,
-                            EpisodeNumber = metadata.EpisodeNumber,
-                            ShowHasContentRating = !string.IsNullOrWhiteSpace(showMetadata.ContentRating),
-                            ShowContentRating = showMetadata.ContentRating,
-                            ShowGuids = showMetadata.Guids.Map(g => g.Guid),
-                            EpisodeGuids = metadata.Guids.Map(g => g.Guid)
-                        };
-                        
-                        var scriptObject = new ScriptObject();
-                        scriptObject.Import(data);
-                        templateContext.PushGlobal(scriptObject);
-
-                        string result = await episodeTemplate.RenderAsync(templateContext);
-
-                        MarkupMinificationResult minified = minifier.Minify(result);
-                        await xml.WriteRawAsync(minified.MinifiedContent);
-                    }
-                }
-                
-                i++;
-                continue;
-            }
-            
-            if (displayItem.MediaItem is MusicVideo templateMusicVideo)
-            {
-                foreach (MusicVideoMetadata metadata in templateMusicVideo.MusicVideoMetadata.HeadOrNone())
-                {
-                    metadata.Genres ??= [];
-                    metadata.Artists ??= [];
-                    metadata.Studios ??= [];
-                    metadata.Directors ??= [];
-                    
-                    string artworkPath = GetPrioritizedArtworkPath(metadata);
+        string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{request.ChannelNumber}.xml");
+        File.Move(tempFile, targetFile, true);
+    }
 
-                    Option<ArtistMetadata> maybeMetadata =
-                        Optional(templateMusicVideo.Artist?.ArtistMetadata.HeadOrNone()).Flatten();
+    private static async Task<Option<string>> ProcessMovieTemplate(
+        RefreshChannelData request,
+        Movie templateMovie,
+        string start,
+        string stop,
+        bool hasCustomTitle,
+        PlayoutItem displayItem,
+        string title,
+        XmlTemplateContext templateContext,
+        Template movieTemplate)
+    {
+        foreach (MovieMetadata metadata in templateMovie.MovieMetadata.HeadOrNone())
+        {
+            metadata.Genres ??= [];
+            metadata.Guids ??= [];
+                    
+            string poster = Optional(metadata.Artwork).Flatten()
+                .Filter(a => a.ArtworkKind == ArtworkKind.Poster)
+                .HeadOrNone()
+                .Match(a => GetArtworkUrl(a, ArtworkKind.Poster), () => string.Empty);
 
-                    var data = new
-                    {
-                        ProgrammeStart = start,
-                        ProgrammeStop = stop,
-                        ChannelNumber = request.ChannelNumber,
-                        HasCustomTitle = hasCustomTitle,
-                        CustomTitle = displayItem.CustomTitle,
-                        ArtistTitle = title,
-                        MusicVideoTitle = subtitle,
-                        MusicVideoHasPlot = !string.IsNullOrWhiteSpace(metadata.Plot),
-                        MusicVideoPlot = metadata.Plot,
-                        MusicVideoHasYear = metadata.Year.HasValue,
-                        MusicVideoYear = metadata.Year,
-                        MusicVideoGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
-                        ArtistGenres = maybeMetadata.SelectMany(m => m.Genres.Map(g => g.Name)).OrderBy(n => n),
-                        MusicVideoHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
-                        MusicVideoArtworkUrl = artworkPath,
-                        MusicVideoHasTrack = metadata.Track.HasValue,
-                        MusicVideoTrack = metadata.Track,
-                        MusicVideoHasAlbum = !string.IsNullOrWhiteSpace(metadata.Album),
-                        MusicVideoAlbum = metadata.Album,
-                        MusicVideoHasReleaseDate = metadata.ReleaseDate.HasValue,
-                        MusicVideoReleaseDate = metadata.ReleaseDate,
-                        MusicVideoAllArtists = metadata.Artists.Map(a => a.Name),
-                        MusicVideoStudios = metadata.Studios.Map(s => s.Name),
-                        MusicVideoDirectors = metadata.Directors.Map(d => d.Name)
-                    };
-
-                    var scriptObject = new ScriptObject();
-                    scriptObject.Import(data);
-                    templateContext.PushGlobal(scriptObject);
-
-                    string result = await musicVideoTemplate.RenderAsync(templateContext);
-
-                    MarkupMinificationResult minified = minifier.Minify(result);
-                    await xml.WriteRawAsync(minified.MinifiedContent);
-                }
+            var data = new
+            {
+                ProgrammeStart = start,
+                ProgrammeStop = stop,
+                ChannelNumber = request.ChannelNumber,
+                HasCustomTitle = hasCustomTitle,
+                CustomTitle = displayItem.CustomTitle,
+                MovieTitle = title,
+                MovieHasPlot = !string.IsNullOrWhiteSpace(metadata.Plot),
+                MoviePlot = metadata.Plot,
+                MovieHasYear = metadata.Year.HasValue,
+                MovieYear = metadata.Year,
+                MovieGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
+                MovieHasArtwork = !string.IsNullOrWhiteSpace(poster),
+                MovieArtworkUrl = poster,
+                MovieHasContentRating = !string.IsNullOrWhiteSpace(metadata.ContentRating),
+                MovieContentRating = metadata.ContentRating,
+                MovieGuids = metadata.Guids.Map(g => g.Guid)
+            };
 
-                i++;
-                continue;
-            }
+            var scriptObject = new ScriptObject();
+            scriptObject.Import(data);
+            templateContext.PushGlobal(scriptObject);
 
-            await xml.WriteStartElementAsync(null, "programme", null);
-            await xml.WriteAttributeStringAsync(null, "start", null, start);
-            await xml.WriteAttributeStringAsync(null, "stop", null, stop);
-            await xml.WriteAttributeStringAsync(null, "channel", null, $"{request.ChannelNumber}.etv");
+            return await movieTemplate.RenderAsync(templateContext);
+        }
 
-            await xml.WriteStartElementAsync(null, "title", null);
-            await xml.WriteAttributeStringAsync(null, "lang", null, "en");
-            await xml.WriteStringAsync(title);
-            await xml.WriteEndElementAsync(); // title
+        return Option<string>.None;
+    }
+    
+    private static async Task<Option<string>> ProcessEpisodeTemplate(
+        RefreshChannelData request,
+        Episode templateEpisode,
+        string start,
+        string stop,
+        bool hasCustomTitle,
+        PlayoutItem displayItem,
+        string title,
+        string subtitle,
+        XmlTemplateContext templateContext,
+        Template episodeTemplate)
+    {
+        foreach (EpisodeMetadata metadata in templateEpisode.EpisodeMetadata.HeadOrNone())
+        {
+            metadata.Genres ??= [];
+            metadata.Guids ??= [];
 
-            if (!string.IsNullOrWhiteSpace(subtitle))
+            foreach (ShowMetadata showMetadata in Optional(
+                         templateEpisode.Season?.Show?.ShowMetadata.HeadOrNone()).Flatten())
             {
-                await xml.WriteStartElementAsync(null, "sub-title", null);
-                await xml.WriteAttributeStringAsync(null, "lang", null, "en");
-                await xml.WriteStringAsync(subtitle);
-                await xml.WriteEndElementAsync(); // subtitle
-            }
+                showMetadata.Genres ??= [];
+                showMetadata.Guids ??= [];
 
-            if (!isSameCustomShow)
-            {
-                if (!string.IsNullOrWhiteSpace(description))
+                string artworkPath = GetPrioritizedArtworkPath(metadata);
+
+                var data = new
                 {
-                    await xml.WriteStartElementAsync(null, "desc", null);
-                    await xml.WriteAttributeStringAsync(null, "lang", null, "en");
-                    await xml.WriteStringAsync(description);
-                    await xml.WriteEndElementAsync(); // desc
-                }
+                    ProgrammeStart = start,
+                    ProgrammeStop = stop,
+                    ChannelNumber = request.ChannelNumber,
+                    HasCustomTitle = hasCustomTitle,
+                    CustomTitle = displayItem.CustomTitle,
+                    ShowTitle = title,
+                    EpisodeHasTitle = !string.IsNullOrWhiteSpace(subtitle),
+                    EpisodeTitle = subtitle,
+                    EpisodeHasPlot = !string.IsNullOrWhiteSpace(metadata.Plot),
+                    EpisodePlot = metadata.Plot,
+                    ShowHasYear = showMetadata.Year.HasValue,
+                    ShowYear = showMetadata.Year,
+                    ShowGenres = showMetadata.Genres.Map(g => g.Name).OrderBy(n => n),
+                    EpisodeHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
+                    EpisodeArtworkUrl = artworkPath,
+                    SeasonNumber = templateEpisode.Season?.SeasonNumber ?? 0,
+                    EpisodeNumber = metadata.EpisodeNumber,
+                    ShowHasContentRating = !string.IsNullOrWhiteSpace(showMetadata.ContentRating),
+                    ShowContentRating = showMetadata.ContentRating,
+                    ShowGuids = showMetadata.Guids.Map(g => g.Guid),
+                    EpisodeGuids = metadata.Guids.Map(g => g.Guid)
+                };
+                
+                var scriptObject = new ScriptObject();
+                scriptObject.Import(data);
+                templateContext.PushGlobal(scriptObject);
+
+                return await episodeTemplate.RenderAsync(templateContext);
             }
+        }
 
-            if (!hasCustomTitle && displayItem.MediaItem is Song song)
-            {
-                await xml.WriteStartElementAsync(null, "category", null);
-                await xml.WriteAttributeStringAsync(null, "lang", null, "en");
-                await xml.WriteStringAsync("Music");
-                await xml.WriteEndElementAsync(); // category
+        return Option<string>.None;
+    }
 
-                foreach (SongMetadata metadata in song.SongMetadata.HeadOrNone())
-                {
-                    string artworkPath = GetPrioritizedArtworkPath(metadata);
-                    if (!string.IsNullOrWhiteSpace(artworkPath))
-                    {
-                        await xml.WriteStartElementAsync(null, "icon", null);
-                        await xml.WriteAttributeStringAsync(null, "src", null, artworkPath);
-                        await xml.WriteEndElementAsync(); // icon
-                    }
-                }
-            }
+    private static async Task<Option<string>> ProcessMusicVideoTemplate(
+        RefreshChannelData request,
+        MusicVideo templateMusicVideo,
+        string start,
+        string stop,
+        bool hasCustomTitle,
+        PlayoutItem displayItem,
+        string title,
+        string subtitle,
+        XmlTemplateContext templateContext,
+        Template musicVideoTemplate)
+    {
+        foreach (MusicVideoMetadata metadata in templateMusicVideo.MusicVideoMetadata.HeadOrNone())
+        {
+            metadata.Genres ??= [];
+            metadata.Artists ??= [];
+            metadata.Studios ??= [];
+            metadata.Directors ??= [];
+
+            string artworkPath = GetPrioritizedArtworkPath(metadata);
 
-            await xml.WriteStartElementAsync(null, "previously-shown", null);
-            await xml.WriteEndElementAsync(); // previously-shown
+            Option<ArtistMetadata> maybeMetadata =
+                Optional(templateMusicVideo.Artist?.ArtistMetadata.HeadOrNone()).Flatten();
 
-            foreach (ContentRating rating in contentRating)
+            var data = new
             {
-                await xml.WriteStartElementAsync(null, "rating", null);
-                foreach (string system in rating.System)
-                {
-                    await xml.WriteAttributeStringAsync(null, "system", null, system);
-                }
+                ProgrammeStart = start,
+                ProgrammeStop = stop,
+                ChannelNumber = request.ChannelNumber,
+                HasCustomTitle = hasCustomTitle,
+                CustomTitle = displayItem.CustomTitle,
+                ArtistTitle = title,
+                MusicVideoTitle = subtitle,
+                MusicVideoHasPlot = !string.IsNullOrWhiteSpace(metadata.Plot),
+                MusicVideoPlot = metadata.Plot,
+                MusicVideoHasYear = metadata.Year.HasValue,
+                MusicVideoYear = metadata.Year,
+                MusicVideoGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
+                ArtistGenres = maybeMetadata.SelectMany(m => m.Genres.Map(g => g.Name)).OrderBy(n => n),
+                MusicVideoHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
+                MusicVideoArtworkUrl = artworkPath,
+                MusicVideoHasTrack = metadata.Track.HasValue,
+                MusicVideoTrack = metadata.Track,
+                MusicVideoHasAlbum = !string.IsNullOrWhiteSpace(metadata.Album),
+                MusicVideoAlbum = metadata.Album,
+                MusicVideoHasReleaseDate = metadata.ReleaseDate.HasValue,
+                MusicVideoReleaseDate = metadata.ReleaseDate,
+                MusicVideoAllArtists = metadata.Artists.Map(a => a.Name),
+                MusicVideoStudios = metadata.Studios.Map(s => s.Name),
+                MusicVideoDirectors = metadata.Directors.Map(d => d.Name)
+            };
 
-                await xml.WriteStartElementAsync(null, "value", null);
-                await xml.WriteStringAsync(rating.Value);
-                await xml.WriteEndElementAsync(); // value
-                await xml.WriteEndElementAsync(); // rating
-            }
+            var scriptObject = new ScriptObject();
+            scriptObject.Import(data);
+            templateContext.PushGlobal(scriptObject);
 
-            await xml.WriteEndElementAsync(); // programme
+            return await musicVideoTemplate.RenderAsync(templateContext);
+        }
 
-            i++;
+        return Option<string>.None;
+    }
+    
+    private async Task<Option<string>> ProcessSongTemplate(
+        RefreshChannelData request,
+        Song templateSong,
+        string start,
+        string stop,
+        bool hasCustomTitle,
+        PlayoutItem displayItem,
+        string title,
+        string subtitle,
+        XmlTemplateContext templateContext,
+        Template songTemplate)
+    {
+        foreach (SongMetadata metadata in templateSong.SongMetadata.HeadOrNone())
+        {
+            metadata.Genres ??= [];
+            metadata.Studios ??= [];
+
+            string artworkPath = GetPrioritizedArtworkPath(metadata);
+
+            var data = new
+            {
+                ProgrammeStart = start,
+                ProgrammeStop = stop,
+                ChannelNumber = request.ChannelNumber,
+                HasCustomTitle = hasCustomTitle,
+                CustomTitle = displayItem.CustomTitle,
+                SongTitle = subtitle,
+                SongArtists = metadata.Artists,
+                SongAlbumArtists = metadata.AlbumArtists,
+                SongHasYear = metadata.Year.HasValue,
+                SongYear = metadata.Year,
+                SongGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
+                SongHasArtwork = !string.IsNullOrWhiteSpace(artworkPath),
+                SongArtworkUrl = artworkPath,
+                SongHasTrack = !string.IsNullOrWhiteSpace(metadata.Track),
+                SongTrack = metadata.Track,
+                SongHasComment = !string.IsNullOrWhiteSpace(metadata.Comment),
+                SongComment = metadata.Comment,
+                SongHasAlbum = !string.IsNullOrWhiteSpace(metadata.Album),
+                SongAlbum = metadata.Album,
+                SongHasReleaseDate = metadata.ReleaseDate.HasValue,
+                SongReleaseDate = metadata.ReleaseDate,
+                SongStudios = metadata.Studios.Map(s => s.Name),
+            };
+
+            var scriptObject = new ScriptObject();
+            scriptObject.Import(data);
+            templateContext.PushGlobal(scriptObject);
+
+            return await songTemplate.RenderAsync(templateContext);
         }
 
-        await xml.FlushAsync();
+        return Option<string>.None;
+    }
+    
+    private static async Task<Option<string>> ProcessOtherVideoTemplate(
+        RefreshChannelData request,
+        OtherVideo templateOtherVideo,
+        string start,
+        string stop,
+        bool hasCustomTitle,
+        PlayoutItem displayItem,
+        string title,
+        XmlTemplateContext templateContext,
+        Template otherVideoTemplate)
+    {
+        foreach (OtherVideoMetadata metadata in templateOtherVideo.OtherVideoMetadata.HeadOrNone())
+        {
+            metadata.Genres ??= [];
+            metadata.Guids ??= [];
+                    
+            var data = new
+            {
+                ProgrammeStart = start,
+                ProgrammeStop = stop,
+                ChannelNumber = request.ChannelNumber,
+                HasCustomTitle = hasCustomTitle,
+                CustomTitle = displayItem.CustomTitle,
+                OtherVideoTitle = title,
+                OtherVideoHasPlot = !string.IsNullOrWhiteSpace(metadata.Plot),
+                OtherVideoPlot = metadata.Plot,
+                OtherVideoHasYear = metadata.Year.HasValue,
+                OtherVideoYear = metadata.Year,
+                OtherVideoGenres = metadata.Genres.Map(g => g.Name).OrderBy(n => n),
+                OtherVideoHasContentRating = !string.IsNullOrWhiteSpace(metadata.ContentRating),
+                OtherVideoContentRating = metadata.ContentRating
+            };
 
-        string tempFile = Path.GetTempFileName();
-        await File.WriteAllBytesAsync(tempFile, ms.ToArray(), cancellationToken);
+            var scriptObject = new ScriptObject();
+            scriptObject.Import(data);
+            templateContext.PushGlobal(scriptObject);
 
-        string targetFile = Path.Combine(FileSystemLayout.ChannelGuideCacheFolder, $"{request.ChannelNumber}.xml");
-        File.Move(tempFile, targetFile, true);
+            return await otherVideoTemplate.RenderAsync(templateContext);
+        }
+
+        return Option<string>.None;
     }
 
     private string GetMovieTemplateFileName()
@@ -524,6 +651,52 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
 
         return templateFileName;
     }
+    
+    private string GetSongTemplateFileName()
+    {
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "song.sbntxt");
+        
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_song.sbntxt");
+        }
+        
+        // fail if file doesn't exist
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            _logger.LogError(
+                "Unable to generate song XMLTV fragment without template file {File}; please restart ErsatzTV",
+                templateFileName);
+
+            return null;
+        }
+
+        return templateFileName;
+    }
+    
+    private string GetOtherVideoTemplateFileName()
+    {
+        string templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "otherVideo.sbntxt");
+        
+        // fall back to default template
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            templateFileName = Path.Combine(FileSystemLayout.ChannelGuideTemplatesFolder, "_otherVideo.sbntxt");
+        }
+        
+        // fail if file doesn't exist
+        if (!_localFileSystem.FileExists(templateFileName))
+        {
+            _logger.LogError(
+                "Unable to generate other video XMLTV fragment without template file {File}; please restart ErsatzTV",
+                templateFileName);
+
+            return null;
+        }
+
+        return templateFileName;
+    }
 
     private static string GetArtworkUrl(Artwork artwork, ArtworkKind artworkKind)
     {
@@ -578,8 +751,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                 .IfNone("[unknown artist]"),
             OtherVideo ov => ov.OtherVideoMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
                 .IfNone("[unknown video]"),
-            Song s => s.SongMetadata.HeadOrNone().Map(sm => sm.Artist ?? string.Empty)
-                .IfNone("[unknown artist]"),
             _ => "[unknown]"
         };
     }
diff --git a/ErsatzTV.Application/MediaCards/Mapper.cs b/ErsatzTV.Application/MediaCards/Mapper.cs
index b5dfee6c2..01007c737 100644
--- a/ErsatzTV.Application/MediaCards/Mapper.cs
+++ b/ErsatzTV.Application/MediaCards/Mapper.cs
@@ -131,7 +131,7 @@ internal static class Mapper
         return new SongCardViewModel(
             songMetadata.SongId,
             songMetadata.Title,
-            songMetadata.Artist + album,
+            string.Join(", ", songMetadata.Artists) + album,
             songMetadata.SortTitle,
             GetThumbnail(songMetadata, None, None),
             songMetadata.Song.State);
diff --git a/ErsatzTV.Application/Playouts/Mapper.cs b/ErsatzTV.Application/Playouts/Mapper.cs
index f336e22ba..432b6d6b0 100644
--- a/ErsatzTV.Application/Playouts/Mapper.cs
+++ b/ErsatzTV.Application/Playouts/Mapper.cs
@@ -66,7 +66,7 @@ internal static class Mapper
                     .IfNone("[unknown video]");
             case Song s:
                 string songArtist = s.SongMetadata.HeadOrNone()
-                    .Map(sm => string.IsNullOrWhiteSpace(sm.Artist) ? string.Empty : $"{sm.Artist} - ")
+                    .Map(sm => $"{string.Join(", ", sm.Artists)} - ")
                     .IfNone(string.Empty);
                 return s.SongMetadata.HeadOrNone()
                     .Map(sm => $"{songArtist}{sm.Title ?? string.Empty}")
diff --git a/ErsatzTV.Core/Domain/Metadata/SongMetadata.cs b/ErsatzTV.Core/Domain/Metadata/SongMetadata.cs
index 617e21225..435502bfe 100644
--- a/ErsatzTV.Core/Domain/Metadata/SongMetadata.cs
+++ b/ErsatzTV.Core/Domain/Metadata/SongMetadata.cs
@@ -3,10 +3,10 @@
 public class SongMetadata : Metadata
 {
     public string Album { get; set; }
-    public string Artist { get; set; }
-    public string AlbumArtist { get; set; }
-    public string Date { get; set; }
+    public IList<string> Artists { get; set; }
+    public IList<string> AlbumArtists { get; set; }
     public string Track { get; set; }
+    public string Comment { get; set; }
     public int SongId { get; set; }
     public Song Song { get; set; }
 }
diff --git a/ErsatzTV.Core/Domain/Metadata/SongTag.cs b/ErsatzTV.Core/Domain/Metadata/SongTag.cs
new file mode 100644
index 000000000..bca4e32e3
--- /dev/null
+++ b/ErsatzTV.Core/Domain/Metadata/SongTag.cs
@@ -0,0 +1,3 @@
+namespace ErsatzTV.Core.Domain;
+
+public record SongTag(string Tag, string Value);
diff --git a/ErsatzTV.Core/FFmpeg/SongVideoGenerator.cs b/ErsatzTV.Core/FFmpeg/SongVideoGenerator.cs
index 2333be440..623938dd4 100644
--- a/ErsatzTV.Core/FFmpeg/SongVideoGenerator.cs
+++ b/ErsatzTV.Core/FFmpeg/SongVideoGenerator.cs
@@ -88,16 +88,18 @@ public class SongVideoGenerator : ISongVideoGenerator
                     sb.Append(CultureInfo.InvariantCulture, $"{{\\fs{largeFontSize}}}{metadata.Title}");
                 }
 
-                if (!string.IsNullOrWhiteSpace(metadata.Artist))
+                if (metadata.Artists.Count > 0)
                 {
-                    sb.Append(CultureInfo.InvariantCulture, $"\\N{{\\fs{fontSize}}}{metadata.Artist}");
+                    var allArtists = string.Join(", ", metadata.Artists);
+                    sb.Append(CultureInfo.InvariantCulture, $"\\N{{\\fs{fontSize}}}{allArtists}");
                 }
             }
             else
             {
-                if (!string.IsNullOrWhiteSpace(metadata.Artist))
+                if (metadata.Artists.Count > 0)
                 {
-                    sb.Append(metadata.Artist);
+                    var allArtists = string.Join(", ", metadata.Artists);
+                    sb.Append(allArtists);
                 }
 
                 if (!string.IsNullOrWhiteSpace(metadata.Title))
@@ -105,12 +107,12 @@ public class SongVideoGenerator : ISongVideoGenerator
                     sb.Append(CultureInfo.InvariantCulture, $"\\N\"{metadata.Title}\"");
                 }
 
-                if (!string.IsNullOrWhiteSpace(metadata.AlbumArtist) && !string.Equals(
-                        metadata.Artist,
-                        metadata.AlbumArtist,
-                        StringComparison.Ordinal))
+                if (metadata.AlbumArtists.Count > 0)
                 {
-                    sb.Append(CultureInfo.InvariantCulture, $"\\N{metadata.AlbumArtist}");
+                    var allAlbumArtists = string.Join(
+                        ", ",
+                        metadata.AlbumArtists.Filter(aa => !metadata.Artists.Contains(aa)));
+                    sb.Append(CultureInfo.InvariantCulture, $"\\N{allAlbumArtists}");
                 }
 
                 if (!string.IsNullOrWhiteSpace(metadata.Album))
diff --git a/ErsatzTV.Core/Interfaces/Metadata/ILocalStatisticsProvider.cs b/ErsatzTV.Core/Interfaces/Metadata/ILocalStatisticsProvider.cs
index 5a1fafe2a..988be076d 100644
--- a/ErsatzTV.Core/Interfaces/Metadata/ILocalStatisticsProvider.cs
+++ b/ErsatzTV.Core/Interfaces/Metadata/ILocalStatisticsProvider.cs
@@ -9,5 +9,5 @@ public interface ILocalStatisticsProvider
     
     Task<Either<BaseError, bool>> RefreshStatistics(string ffmpegPath, string ffprobePath, MediaItem mediaItem);
 
-    Task<Either<BaseError, Dictionary<string, string>>> GetSongTags(string ffprobePath, MediaItem mediaItem);
+    Either<BaseError, List<SongTag>> GetSongTags(string ffprobePath, MediaItem mediaItem);
 }
diff --git a/ErsatzTV.Core/Scheduling/ChronologicalMediaComparer.cs b/ErsatzTV.Core/Scheduling/ChronologicalMediaComparer.cs
index d042a5a61..ae82a0436 100644
--- a/ErsatzTV.Core/Scheduling/ChronologicalMediaComparer.cs
+++ b/ErsatzTV.Core/Scheduling/ChronologicalMediaComparer.cs
@@ -45,23 +45,6 @@ internal class ChronologicalMediaComparer : IComparer<MediaItem>
             return date1.CompareTo(date2);
         }
 
-        string songDate1 = x switch
-        {
-            Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Date ?? string.Empty, () => string.Empty),
-            _ => string.Empty
-        };
-
-        string songDate2 = y switch
-        {
-            Song s => s.SongMetadata.HeadOrNone().Match(sm => sm.Date ?? string.Empty, () => string.Empty),
-            _ => string.Empty
-        };
-
-        if (songDate1 != songDate2)
-        {
-            return string.Compare(songDate1, songDate2, StringComparison.Ordinal);
-        }
-
         int season1 = x switch
         {
             Episode e => e.Season?.SeasonNumber ?? int.MaxValue,
diff --git a/ErsatzTV.Infrastructure.MySql/Migrations/20240209170144_Update_SongMetadataParity.Designer.cs b/ErsatzTV.Infrastructure.MySql/Migrations/20240209170144_Update_SongMetadataParity.Designer.cs
new file mode 100644
index 000000000..de063ff21
--- /dev/null
+++ b/ErsatzTV.Infrastructure.MySql/Migrations/20240209170144_Update_SongMetadataParity.Designer.cs
@@ -0,0 +1,4925 @@
+// <auto-generated />
+using System;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.MySql.Migrations
+{
+    [DbContext(typeof(TvContext))]
+    [Migration("20240209170144_Update_SongMetadataParity")]
+    partial class Update_SongMetadataParity
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.1")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Actor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtworkId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Order")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("ArtworkId")
+                        .IsUnique();
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Actor", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("ArtistId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Biography")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Disambiguation")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Formed")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("ArtistMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artwork", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ArtworkKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("BlurHash43")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("BlurHash54")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("BlurHash64")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("ChannelId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourcePath")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("ChannelId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Artwork", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Categories")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("FFmpegProfileId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("FallbackFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Group")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("longtext")
+                        .HasDefaultValue("ErsatzTV");
+
+                    b.Property<int>("MusicVideoCreditsMode")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MusicVideoCreditsTemplate")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("StreamingMode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubtitleMode")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("UniqueId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FFmpegProfileId");
+
+                    b.HasIndex("FallbackFillerId");
+
+                    b.HasIndex("Number")
+                        .IsUnique();
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("Channel", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ChannelWatermark", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("DurationSeconds")
+                        .HasColumnType("int");
+
+                    b.Property<int>("FrequencyMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<int>("HorizontalMarginPercent")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Image")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("ImageSource")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Location")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Mode")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("Opacity")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("PlaceWithinSourceContent")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("Size")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VerticalMarginPercent")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WidthPercent")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ChannelWatermark", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Collection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("UseCustomPlaybackOrder")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Collection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.CollectionItem", b =>
+                {
+                    b.Property<int>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CustomIndex")
+                        .HasColumnType("int");
+
+                    b.HasKey("CollectionId", "MediaItemId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.ToTable("CollectionItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ConfigElement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key")
+                        .IsUnique();
+
+                    b.ToTable("ConfigElement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Director", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.ToTable("Director", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmbyCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("EmbyMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyMediaSourceId");
+
+                    b.ToTable("EmbyConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmbyMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EmbyPath")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyMediaSourceId");
+
+                    b.ToTable("EmbyPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EpisodeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EpisodeNumber")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeId");
+
+                    b.ToTable("EpisodeMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.FFmpegProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("AudioBitrate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("AudioBufferSize")
+                        .HasColumnType("int");
+
+                    b.Property<int>("AudioChannels")
+                        .HasColumnType("int");
+
+                    b.Property<int>("AudioFormat")
+                        .HasColumnType("int");
+
+                    b.Property<int>("AudioSampleRate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BitDepth")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("DeinterlaceVideo")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("HardwareAcceleration")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("NormalizeFramerate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<int>("NormalizeLoudnessMode")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("QsvExtraHardwareFrames")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ResolutionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ScalingBehavior")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ThreadCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("VaapiDevice")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("VaapiDriver")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VideoBitrate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VideoBufferSize")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VideoFormat")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ResolutionId");
+
+                    b.ToTable("FFmpegProfile", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Filler.FillerPreset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowWatermarks")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("Duration")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("FillerKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("FillerMode")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("PadToNearestMinute")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("FillerPreset", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Genre", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Genre");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("JellyfinCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("JellyfinMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinMediaSourceId");
+
+                    b.ToTable("JellyfinConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("JellyfinMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("JellyfinPath")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinMediaSourceId");
+
+                    b.ToTable("JellyfinPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LanguageCode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("EnglishName")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FrenchName")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ThreeCode1")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ThreeCode2")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("TwoCode")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LanguageCode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastScan")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MediaKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MediaSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaSourceId");
+
+                    b.ToTable("Library", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryFolder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("LibraryPathId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryPathId");
+
+                    b.ToTable("LibraryFolder", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastScan")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LibraryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryId");
+
+                    b.ToTable("LibraryPath", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaChapter", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<long>("ChapterId")
+                        .HasColumnType("bigint");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.ToTable("MediaChapter", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("varchar(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.HasIndex("Path")
+                        .IsUnique();
+
+                    b.ToTable("MediaFile", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("LibraryPathId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("State")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryPathId");
+
+                    b.ToTable("MediaItem", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MediaSource", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaStream", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AttachedPic")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("BitsPerRawSample")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Channels")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ColorPrimaries")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ColorRange")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ColorSpace")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ColorTransfer")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("Default")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("Forced")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("MediaStreamKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MimeType")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PixelFormat")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Profile")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.ToTable("MediaStream", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DisplayAspectRatio")
+                        .HasColumnType("longtext");
+
+                    b.Property<TimeSpan>("Duration")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("EpisodeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RFrameRate")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("SampleAspectRatio")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("SongId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VideoScanKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeId");
+
+                    b.HasIndex("MovieId");
+
+                    b.HasIndex("MusicVideoId");
+
+                    b.HasIndex("OtherVideoId");
+
+                    b.HasIndex("SongId");
+
+                    b.ToTable("MediaVersion", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MetadataGuid", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Guid")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("MetadataGuid", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Mood", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.ToTable("Mood");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MovieId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MovieId");
+
+                    b.ToTable("MovieMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MultiCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionItem", b =>
+                {
+                    b.Property<int>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("ScheduleAsGroup")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("MultiCollectionId", "CollectionId");
+
+                    b.HasIndex("CollectionId");
+
+                    b.ToTable("MultiCollectionItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionSmartItem", b =>
+                {
+                    b.Property<int>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SmartCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("ScheduleAsGroup")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("MultiCollectionId", "SmartCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("MultiCollectionSmartItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoArtist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.ToTable("MusicVideoArtist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MusicVideoId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Track")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MusicVideoId");
+
+                    b.ToTable("MusicVideoMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("OtherVideoId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OtherVideoId");
+
+                    b.ToTable("OtherVideoMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("ChannelId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("DailyRebuildTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("ExternalJsonFile")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("ProgramScheduleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProgramSchedulePlayoutType")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Seed")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.ToTable("Playout", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("BlockKey")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ChapterTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("CollectionEtag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("CollectionKey")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("CustomTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("DisableWatermarks")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("FillerKind")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Finish")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("GuideFinish")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GuideGroup")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("InPoint")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("OutPoint")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("Start")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SubtitleMode")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("PlayoutItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutProgramScheduleAnchor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("AnchorDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FakeCollectionKey")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("PlayoutProgramScheduleAnchor", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutScheduleItemFillGroupIndex", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProgramScheduleItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("ProgramScheduleItemId");
+
+                    b.ToTable("PlayoutScheduleItemFillGroupIndex", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PlexCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("PlexMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Uri")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexMediaSourceId");
+
+                    b.ToTable("PlexConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("PlexMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PlexPath")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexMediaSourceId");
+
+                    b.ToTable("PlexPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<bool>("KeepMultiPartEpisodesTogether")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<bool>("RandomStartPoint")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("ShuffleScheduleItems")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("TreatCollectionsAsShows")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ProgramSchedule", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleAlternate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("DaysOfMonth")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("DaysOfWeek")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MonthsOfYear")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.ToTable("ProgramScheduleAlternate", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FakeCollectionKey")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("FallbackFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("FillWithGroupMode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("GuideMode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MidRollFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("PostRollFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("PreRollFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("SubtitleMode")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TailFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("FallbackFillerId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MidRollFillerId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("PostRollFillerId");
+
+                    b.HasIndex("PreRollFillerId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.HasIndex("TailFillerId");
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("ProgramScheduleItem", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Resolution", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsCustom")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Resolution", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("BlockGroupId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Minutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<int>("StopScheduling")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockGroupId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Block", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("BlockGroup", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("BlockItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Details")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("When")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.ToTable("PlayoutHistory", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutTemplate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DaysOfMonth")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("DaysOfWeek")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTimeOffset>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MonthsOfYear")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("PlayoutTemplate", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<int>("TemplateGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("TemplateGroupId");
+
+                    b.ToTable("Template", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("TemplateGroup", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("TemplateItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SeasonId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("SeasonMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ShowId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ShowId");
+
+                    b.ToTable("ShowMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SmartCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Query")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SmartCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("AlbumArtists")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Artists")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SongId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Track")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SongId");
+
+                    b.ToTable("SongMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Studio", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Studio", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Style", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.ToTable("Style");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Subtitle", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("Default")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Forced")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsExtracted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Language")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("SDH")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StreamIndex")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubtitleKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Subtitle", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Tag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ExternalCollectionId")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Tag");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktList", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("ItemCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("List")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("TraktId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("User")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TraktList", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("Episode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Rank")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("Season")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("TraktId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TraktListId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("TraktListId");
+
+                    b.ToTable("TraktListItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItemGuid", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Guid")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("TraktListItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TraktListItemId");
+
+                    b.ToTable("TraktListItemGuid", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Writer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.ToTable("Writer", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Emby.EmbyPathInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EmbyLibraryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("NetworkPath")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyLibraryId");
+
+                    b.ToTable("EmbyPathInfo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Jellyfin.JellyfinPathInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("JellyfinLibraryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("NetworkPath")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinLibraryId");
+
+                    b.ToTable("JellyfinPathInfo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("tinyint(1)");
+
+                    b.ToTable("EmbyLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("tinyint(1)");
+
+                    b.ToTable("JellyfinLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.ToTable("LocalLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("tinyint(1)");
+
+                    b.ToTable("PlexLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaFile", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaFile");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("PlexId")
+                        .HasColumnType("int");
+
+                    b.ToTable("PlexMediaFile", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Artist", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("SeasonId")
+                        .HasColumnType("int");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("Episode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Movie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("ArtistId")
+                        .HasColumnType("int");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("MusicVideo", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("OtherVideo", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("SeasonNumber")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ShowId")
+                        .HasColumnType("int");
+
+                    b.HasIndex("ShowId");
+
+                    b.ToTable("Season", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Show", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Song", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("OperatingSystem")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("EmbyMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("OperatingSystem")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("JellyfinMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.ToTable("LocalMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<string>("ClientIdentifier")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Platform")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PlatformVersion")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ProductVersion")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("PlexMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.Property<int>("DiscardToFillAttempts")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("PlayoutDuration")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("TailMode")
+                        .HasColumnType("int");
+
+                    b.ToTable("ProgramScheduleDurationItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.ToTable("ProgramScheduleFloodItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.ToTable("ProgramScheduleMultipleItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemOne", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.ToTable("ProgramScheduleOneItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("EmbyEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("JellyfinEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("PlexEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("EmbyMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("JellyfinMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("PlexMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbySeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("EmbySeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinSeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("JellyfinSeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexSeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("PlexSeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("EmbyShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("JellyfinShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("PlexShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Actor", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Artwork", "Artwork")
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Actor", "ArtworkId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Artwork");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Artist", "Artist")
+                        .WithMany("ArtistMetadata")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Artist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artwork", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Channel", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.FFmpegProfile", "FFmpegProfile")
+                        .WithMany()
+                        .HasForeignKey("FFmpegProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "FallbackFiller")
+                        .WithMany()
+                        .HasForeignKey("FallbackFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("FFmpegProfile");
+
+                    b.Navigation("FallbackFiller");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.CollectionItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany("CollectionItems")
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany("CollectionItems")
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Director", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyMediaSource", "EmbyMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("EmbyMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmbyMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyMediaSource", "EmbyMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("EmbyMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmbyMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", "Episode")
+                        .WithMany("EpisodeMetadata")
+                        .HasForeignKey("EpisodeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Episode");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.FFmpegProfile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Resolution", "Resolution")
+                        .WithMany()
+                        .HasForeignKey("ResolutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Resolution");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Filler.FillerPreset", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Genre", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinMediaSource", "JellyfinMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("JellyfinMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JellyfinMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinMediaSource", "JellyfinMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("JellyfinMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JellyfinMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", "MediaSource")
+                        .WithMany("Libraries")
+                        .HasForeignKey("MediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryFolder", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.LibraryPath", "LibraryPath")
+                        .WithMany("LibraryFolders")
+                        .HasForeignKey("LibraryPathId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LibraryPath");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", "Library")
+                        .WithMany("Paths")
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Library");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaChapter", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("Chapters")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaFile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("MediaFiles")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.LibraryPath", "LibraryPath")
+                        .WithMany("MediaItems")
+                        .HasForeignKey("LibraryPathId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LibraryPath");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaStream", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("Streams")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("EpisodeId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("MovieId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideo", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("MusicVideoId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideo", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("OtherVideoId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Song", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("SongId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MetadataGuid", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Mood", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Moods")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", "Movie")
+                        .WithMany("MovieMetadata")
+                        .HasForeignKey("MovieId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Movie");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany("MultiCollectionItems")
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany("MultiCollectionItems")
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MultiCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionSmartItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany("MultiCollectionSmartItems")
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany("MultiCollectionSmartItems")
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoArtist", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Artists")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideo", "MusicVideo")
+                        .WithMany("MusicVideoMetadata")
+                        .HasForeignKey("MusicVideoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MusicVideo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideo", "OtherVideo")
+                        .WithMany("OtherVideoMetadata")
+                        .HasForeignKey("OtherVideoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OtherVideo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Channel", "Channel")
+                        .WithMany("Playouts")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("Playouts")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.PlayoutAnchor", "Anchor", b1 =>
+                        {
+                            b1.Property<int>("PlayoutId")
+                                .HasColumnType("int");
+
+                            b1.Property<DateTime?>("DurationFinish")
+                                .HasColumnType("datetime(6)");
+
+                            b1.Property<bool>("InDurationFiller")
+                                .HasColumnType("tinyint(1)");
+
+                            b1.Property<bool>("InFlood")
+                                .HasColumnType("tinyint(1)");
+
+                            b1.Property<int?>("MultipleRemaining")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("NextGuideGroup")
+                                .HasColumnType("int");
+
+                            b1.Property<DateTime>("NextStart")
+                                .HasColumnType("datetime(6)");
+
+                            b1.HasKey("PlayoutId");
+
+                            b1.ToTable("PlayoutAnchor", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutId");
+
+                            b1.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "ScheduleItemsEnumeratorState", b2 =>
+                                {
+                                    b2.Property<int>("PlayoutAnchorPlayoutId")
+                                        .HasColumnType("int");
+
+                                    b2.Property<int>("Index")
+                                        .HasColumnType("int");
+
+                                    b2.Property<int>("Seed")
+                                        .HasColumnType("int");
+
+                                    b2.HasKey("PlayoutAnchorPlayoutId");
+
+                                    b2.ToTable("ScheduleItemsEnumeratorState", (string)null);
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("PlayoutAnchorPlayoutId");
+                                });
+
+                            b1.Navigation("ScheduleItemsEnumeratorState");
+                        });
+
+                    b.Navigation("Anchor");
+
+                    b.Navigation("Channel");
+
+                    b.Navigation("ProgramSchedule");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("Items")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutProgramScheduleAnchor", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("ProgramScheduleAnchors")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "EnumeratorState", b1 =>
+                        {
+                            b1.Property<int>("PlayoutProgramScheduleAnchorId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Index")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Seed")
+                                .HasColumnType("int");
+
+                            b1.HasKey("PlayoutProgramScheduleAnchorId");
+
+                            b1.ToTable("CollectionEnumeratorState", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutProgramScheduleAnchorId");
+                        });
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("EnumeratorState");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutScheduleItemFillGroupIndex", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("FillGroupIndices")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", "ProgramScheduleItem")
+                        .WithMany()
+                        .HasForeignKey("ProgramScheduleItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "EnumeratorState", b1 =>
+                        {
+                            b1.Property<int>("PlayoutScheduleItemFillGroupIndexId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Index")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Seed")
+                                .HasColumnType("int");
+
+                            b1.HasKey("PlayoutScheduleItemFillGroupIndexId");
+
+                            b1.ToTable("FillGroupEnumeratorState", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutScheduleItemFillGroupIndexId");
+                        });
+
+                    b.Navigation("EnumeratorState");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("ProgramScheduleItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.PlexMediaSource", "PlexMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("PlexMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PlexMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.PlexMediaSource", "PlexMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("PlexMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PlexMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleAlternate", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("ProgramScheduleAlternates")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("ProgramScheduleAlternates")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("ProgramSchedule");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "FallbackFiller")
+                        .WithMany()
+                        .HasForeignKey("FallbackFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "MidRollFiller")
+                        .WithMany()
+                        .HasForeignKey("MidRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PostRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PostRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PreRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PreRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("Items")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "TailFiller")
+                        .WithMany()
+                        .HasForeignKey("TailFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("FallbackFiller");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MidRollFiller");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("PostRollFiller");
+
+                    b.Navigation("PreRollFiller");
+
+                    b.Navigation("ProgramSchedule");
+
+                    b.Navigation("SmartCollection");
+
+                    b.Navigation("TailFiller");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.BlockGroup", "BlockGroup")
+                        .WithMany("Blocks")
+                        .HasForeignKey("BlockGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BlockGroup");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("Items")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutHistory", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("PlayoutHistory")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("PlayoutHistory")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Playout");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutTemplate", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("Templates")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Template", "Template")
+                        .WithMany("PlayoutTemplates")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", "TemplateGroup")
+                        .WithMany("Templates")
+                        .HasForeignKey("TemplateGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TemplateGroup");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("TemplateItems")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Template", "Template")
+                        .WithMany("Items")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", "Season")
+                        .WithMany("SeasonMetadata")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", "Show")
+                        .WithMany("ShowMetadata")
+                        .HasForeignKey("ShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Song", "Song")
+                        .WithMany("SongMetadata")
+                        .HasForeignKey("SongId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Song");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Studio", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Style", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Styles")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Subtitle", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Tag", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany("TraktListItems")
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.TraktList", "TraktList")
+                        .WithMany("Items")
+                        .HasForeignKey("TraktListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("TraktList");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItemGuid", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.TraktListItem", "TraktListItem")
+                        .WithMany("Guids")
+                        .HasForeignKey("TraktListItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TraktListItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Writer", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Emby.EmbyPathInfo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyLibrary", null)
+                        .WithMany("PathInfos")
+                        .HasForeignKey("EmbyLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Jellyfin.JellyfinPathInfo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinLibrary", null)
+                        .WithMany("PathInfos")
+                        .HasForeignKey("JellyfinLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.LocalLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaFile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaFile", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMediaFile", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Artist", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Episode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Season", "Season")
+                        .WithMany("Episodes")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Movie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Artist", "Artist")
+                        .WithMany("MusicVideos")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.MusicVideo", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Artist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.OtherVideo", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Season", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Show", "Show")
+                        .WithMany("Seasons")
+                        .HasForeignKey("ShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Show", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Song", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.LocalMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemOne", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemOne", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbySeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbySeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinSeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinSeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexSeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexSeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Moods");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Styles");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Playouts");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Collection", b =>
+                {
+                    b.Navigation("CollectionItems");
+
+                    b.Navigation("MultiCollectionItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.Navigation("Paths");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.Navigation("LibraryFolders");
+
+                    b.Navigation("MediaItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.Navigation("CollectionItems");
+
+                    b.Navigation("TraktListItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaSource", b =>
+                {
+                    b.Navigation("Libraries");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.Navigation("Chapters");
+
+                    b.Navigation("MediaFiles");
+
+                    b.Navigation("Streams");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollection", b =>
+                {
+                    b.Navigation("MultiCollectionItems");
+
+                    b.Navigation("MultiCollectionSmartItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artists");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.Navigation("FillGroupIndices");
+
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutHistory");
+
+                    b.Navigation("ProgramScheduleAlternates");
+
+                    b.Navigation("ProgramScheduleAnchors");
+
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramSchedule", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Playouts");
+
+                    b.Navigation("ProgramScheduleAlternates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutHistory");
+
+                    b.Navigation("TemplateItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockGroup", b =>
+                {
+                    b.Navigation("Blocks");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutTemplates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", b =>
+                {
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SmartCollection", b =>
+                {
+                    b.Navigation("MultiCollectionSmartItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktList", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.Navigation("Guids");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.Navigation("PathInfos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.Navigation("PathInfos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.Navigation("ArtistMetadata");
+
+                    b.Navigation("MusicVideos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.Navigation("EpisodeMetadata");
+
+                    b.Navigation("MediaVersions");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("MovieMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("MusicVideoMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("OtherVideoMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.Navigation("Episodes");
+
+                    b.Navigation("SeasonMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.Navigation("Seasons");
+
+                    b.Navigation("ShowMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("SongMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/ErsatzTV.Infrastructure.MySql/Migrations/20240209170144_Update_SongMetadataParity.cs b/ErsatzTV.Infrastructure.MySql/Migrations/20240209170144_Update_SongMetadataParity.cs
new file mode 100644
index 000000000..a7f27bc58
--- /dev/null
+++ b/ErsatzTV.Infrastructure.MySql/Migrations/20240209170144_Update_SongMetadataParity.cs
@@ -0,0 +1,48 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.MySql.Migrations
+{
+    /// <inheritdoc />
+    public partial class Update_SongMetadataParity : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "Date",
+                table: "SongMetadata",
+                newName: "Comment");
+
+            migrationBuilder.RenameColumn(
+                name: "Artist",
+                table: "SongMetadata",
+                newName: "Artists");
+
+            migrationBuilder.RenameColumn(
+                name: "AlbumArtist",
+                table: "SongMetadata",
+                newName: "AlbumArtists");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "Comment",
+                table: "SongMetadata",
+                newName: "Date");
+
+            migrationBuilder.RenameColumn(
+                name: "Artists",
+                table: "SongMetadata",
+                newName: "Artist");
+
+            migrationBuilder.RenameColumn(
+                name: "AlbumArtists",
+                table: "SongMetadata",
+                newName: "AlbumArtist");
+        }
+    }
+}
diff --git a/ErsatzTV.Infrastructure.MySql/Migrations/20240209170532_Reset_SongMetadataTagLib.Designer.cs b/ErsatzTV.Infrastructure.MySql/Migrations/20240209170532_Reset_SongMetadataTagLib.Designer.cs
new file mode 100644
index 000000000..472abca27
--- /dev/null
+++ b/ErsatzTV.Infrastructure.MySql/Migrations/20240209170532_Reset_SongMetadataTagLib.Designer.cs
@@ -0,0 +1,4925 @@
+// <auto-generated />
+using System;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.MySql.Migrations
+{
+    [DbContext(typeof(TvContext))]
+    [Migration("20240209170532_Reset_SongMetadataTagLib")]
+    partial class Reset_SongMetadataTagLib
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "8.0.1")
+                .HasAnnotation("Relational:MaxIdentifierLength", 64);
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Actor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtworkId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Order")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("ArtworkId")
+                        .IsUnique();
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Actor", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("ArtistId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Biography")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Disambiguation")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Formed")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("ArtistMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artwork", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ArtworkKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("BlurHash43")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("BlurHash54")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("BlurHash64")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("ChannelId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourcePath")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("ChannelId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Artwork", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Categories")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("FFmpegProfileId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("FallbackFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Group")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("longtext")
+                        .HasDefaultValue("ErsatzTV");
+
+                    b.Property<int>("MusicVideoCreditsMode")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MusicVideoCreditsTemplate")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("StreamingMode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubtitleMode")
+                        .HasColumnType("int");
+
+                    b.Property<Guid>("UniqueId")
+                        .HasColumnType("char(36)");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FFmpegProfileId");
+
+                    b.HasIndex("FallbackFillerId");
+
+                    b.HasIndex("Number")
+                        .IsUnique();
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("Channel", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ChannelWatermark", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("DurationSeconds")
+                        .HasColumnType("int");
+
+                    b.Property<int>("FrequencyMinutes")
+                        .HasColumnType("int");
+
+                    b.Property<int>("HorizontalMarginPercent")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Image")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("ImageSource")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Location")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Mode")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("Opacity")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("PlaceWithinSourceContent")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("Size")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VerticalMarginPercent")
+                        .HasColumnType("int");
+
+                    b.Property<int>("WidthPercent")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ChannelWatermark", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Collection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("UseCustomPlaybackOrder")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Collection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.CollectionItem", b =>
+                {
+                    b.Property<int>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CustomIndex")
+                        .HasColumnType("int");
+
+                    b.HasKey("CollectionId", "MediaItemId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.ToTable("CollectionItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ConfigElement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key")
+                        .IsUnique();
+
+                    b.ToTable("ConfigElement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Director", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.ToTable("Director", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmbyCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("EmbyMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyMediaSourceId");
+
+                    b.ToTable("EmbyConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("EmbyMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("EmbyPath")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyMediaSourceId");
+
+                    b.ToTable("EmbyPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("EpisodeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("EpisodeNumber")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeId");
+
+                    b.ToTable("EpisodeMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.FFmpegProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("AudioBitrate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("AudioBufferSize")
+                        .HasColumnType("int");
+
+                    b.Property<int>("AudioChannels")
+                        .HasColumnType("int");
+
+                    b.Property<int>("AudioFormat")
+                        .HasColumnType("int");
+
+                    b.Property<int>("AudioSampleRate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("BitDepth")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("DeinterlaceVideo")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("HardwareAcceleration")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("NormalizeFramerate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<int>("NormalizeLoudnessMode")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("QsvExtraHardwareFrames")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ResolutionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ScalingBehavior")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ThreadCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("VaapiDevice")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("VaapiDriver")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VideoBitrate")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VideoBufferSize")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VideoFormat")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ResolutionId");
+
+                    b.ToTable("FFmpegProfile", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Filler.FillerPreset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AllowWatermarks")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("Count")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("Duration")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("FillerKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("FillerMode")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("PadToNearestMinute")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("FillerPreset", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Genre", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Genre");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("JellyfinCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("JellyfinMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinMediaSourceId");
+
+                    b.ToTable("JellyfinConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("JellyfinMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("JellyfinPath")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinMediaSourceId");
+
+                    b.ToTable("JellyfinPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LanguageCode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("EnglishName")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FrenchName")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ThreeCode1")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ThreeCode2")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("TwoCode")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LanguageCode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastScan")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MediaKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MediaSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaSourceId");
+
+                    b.ToTable("Library", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryFolder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("LibraryPathId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryPathId");
+
+                    b.ToTable("LibraryFolder", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("LastScan")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("LibraryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryId");
+
+                    b.ToTable("LibraryPath", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaChapter", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<long>("ChapterId")
+                        .HasColumnType("bigint");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.ToTable("MediaChapter", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("varchar(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.HasIndex("Path")
+                        .IsUnique();
+
+                    b.ToTable("MediaFile", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("LibraryPathId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("State")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryPathId");
+
+                    b.ToTable("MediaItem", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MediaSource", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaStream", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<bool>("AttachedPic")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("BitsPerRawSample")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Channels")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ColorPrimaries")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ColorRange")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ColorSpace")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ColorTransfer")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("Default")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("Forced")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("MediaStreamKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MimeType")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PixelFormat")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Profile")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.ToTable("MediaStream", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DisplayAspectRatio")
+                        .HasColumnType("longtext");
+
+                    b.Property<TimeSpan>("Duration")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("EpisodeId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RFrameRate")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("SampleAspectRatio")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("SongId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("VideoScanKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeId");
+
+                    b.HasIndex("MovieId");
+
+                    b.HasIndex("MusicVideoId");
+
+                    b.HasIndex("OtherVideoId");
+
+                    b.HasIndex("SongId");
+
+                    b.ToTable("MediaVersion", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MetadataGuid", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Guid")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("MetadataGuid", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Mood", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.ToTable("Mood");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MovieId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MovieId");
+
+                    b.ToTable("MovieMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MultiCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionItem", b =>
+                {
+                    b.Property<int>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("ScheduleAsGroup")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("MultiCollectionId", "CollectionId");
+
+                    b.HasIndex("CollectionId");
+
+                    b.ToTable("MultiCollectionItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionSmartItem", b =>
+                {
+                    b.Property<int>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SmartCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("ScheduleAsGroup")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("MultiCollectionId", "SmartCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("MultiCollectionSmartItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoArtist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.ToTable("MusicVideoArtist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MusicVideoId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Track")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MusicVideoId");
+
+                    b.ToTable("MusicVideoMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("OtherVideoId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OtherVideoId");
+
+                    b.ToTable("OtherVideoMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("ChannelId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("DailyRebuildTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<string>("ExternalJsonFile")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("ProgramScheduleId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProgramSchedulePlayoutType")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Seed")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.ToTable("Playout", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("BlockKey")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ChapterTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("CollectionEtag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("CollectionKey")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("CustomTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("DisableWatermarks")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("FillerKind")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("Finish")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime?>("GuideFinish")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("GuideGroup")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("InPoint")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("OutPoint")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("Start")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("SubtitleMode")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("PlayoutItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutProgramScheduleAnchor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime?>("AnchorDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FakeCollectionKey")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("PlayoutProgramScheduleAnchor", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutScheduleItemFillGroupIndex", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProgramScheduleItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("ProgramScheduleItemId");
+
+                    b.ToTable("PlayoutScheduleItemFillGroupIndex", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PlexCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int>("PlexMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Uri")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexMediaSourceId");
+
+                    b.ToTable("PlexConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("PlexMediaSourceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PlexPath")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexMediaSourceId");
+
+                    b.ToTable("PlexPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<bool>("KeepMultiPartEpisodesTogether")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<bool>("RandomStartPoint")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("ShuffleScheduleItems")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("TreatCollectionsAsShows")
+                        .HasColumnType("tinyint(1)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ProgramSchedule", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleAlternate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("DaysOfMonth")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("DaysOfWeek")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MonthsOfYear")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.ToTable("ProgramScheduleAlternate", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("int");
+
+                    b.Property<string>("CustomTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("FakeCollectionKey")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("FallbackFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("FillWithGroupMode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("GuideMode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MidRollFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("PostRollFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("PreRollFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan?>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int?>("SubtitleMode")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("TailFillerId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("FallbackFillerId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MidRollFillerId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("PostRollFillerId");
+
+                    b.HasIndex("PreRollFillerId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.HasIndex("TailFillerId");
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("ProgramScheduleItem", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Resolution", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsCustom")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Resolution", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("BlockGroupId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Minutes")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<int>("StopScheduling")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockGroupId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Block", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("BlockGroup", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("BlockItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Details")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("When")
+                        .HasColumnType("datetime(6)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.ToTable("PlayoutHistory", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutTemplate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("DaysOfMonth")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("DaysOfWeek")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTimeOffset>("EndDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MonthsOfYear")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("StartDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("PlayoutTemplate", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.Property<int>("TemplateGroupId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("TemplateGroupId");
+
+                    b.ToTable("Template", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("varchar(255)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("TemplateGroup", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("TemplateItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SeasonId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("SeasonMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("ShowId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ShowId");
+
+                    b.ToTable("ShowMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SmartCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Query")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SmartCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("AlbumArtists")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Artists")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<int>("SongId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Track")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SongId");
+
+                    b.ToTable("SongMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Studio", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Studio", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Style", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.ToTable("Style");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Subtitle", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<bool>("Default")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("Forced")
+                        .HasColumnType("tinyint(1)");
+
+                    b.Property<bool>("IsExtracted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Language")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("SDH")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("tinyint(1)")
+                        .HasDefaultValue(false);
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("StreamIndex")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SubtitleKind")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Subtitle", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Tag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("ExternalCollectionId")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Tag");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktList", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("ItemCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("List")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("TraktId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("User")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TraktList", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("Episode")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("Rank")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("Season")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("TraktId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TraktListId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("TraktListId");
+
+                    b.ToTable("TraktListItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItemGuid", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<string>("Guid")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("TraktListItemId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TraktListItemId");
+
+                    b.ToTable("TraktListItemGuid", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Writer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("longtext");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.ToTable("Writer", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Emby.EmbyPathInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("EmbyLibraryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("NetworkPath")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyLibraryId");
+
+                    b.ToTable("EmbyPathInfo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Jellyfin.JellyfinPathInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    b.Property<int?>("JellyfinLibraryId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("NetworkPath")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("longtext");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinLibraryId");
+
+                    b.ToTable("JellyfinPathInfo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("tinyint(1)");
+
+                    b.ToTable("EmbyLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("tinyint(1)");
+
+                    b.ToTable("JellyfinLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.ToTable("LocalLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("tinyint(1)");
+
+                    b.ToTable("PlexLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaFile", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaFile");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.Property<int>("PlexId")
+                        .HasColumnType("int");
+
+                    b.ToTable("PlexMediaFile", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Artist", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("SeasonId")
+                        .HasColumnType("int");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("Episode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Movie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("ArtistId")
+                        .HasColumnType("int");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("MusicVideo", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("OtherVideo", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("SeasonNumber")
+                        .HasColumnType("int");
+
+                    b.Property<int>("ShowId")
+                        .HasColumnType("int");
+
+                    b.HasIndex("ShowId");
+
+                    b.ToTable("Season", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Show", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Song", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("OperatingSystem")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("EmbyMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("OperatingSystem")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("JellyfinMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.ToTable("LocalMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<string>("ClientIdentifier")
+                        .HasColumnType("longtext");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("datetime(6)");
+
+                    b.Property<string>("Platform")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("PlatformVersion")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ProductVersion")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("PlexMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.Property<int>("DiscardToFillAttempts")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("PlayoutDuration")
+                        .HasColumnType("time(6)");
+
+                    b.Property<int>("TailMode")
+                        .HasColumnType("int");
+
+                    b.ToTable("ProgramScheduleDurationItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.ToTable("ProgramScheduleFloodItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.Property<int>("Count")
+                        .HasColumnType("int");
+
+                    b.ToTable("ProgramScheduleMultipleItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemOne", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.ToTable("ProgramScheduleOneItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("EmbyEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("JellyfinEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("PlexEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("EmbyMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("JellyfinMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("PlexMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbySeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("EmbySeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinSeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("JellyfinSeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexSeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("PlexSeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("EmbyShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("JellyfinShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("longtext");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("longtext");
+
+                    b.ToTable("PlexShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Actor", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Artwork", "Artwork")
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Actor", "ArtworkId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Artwork");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Artist", "Artist")
+                        .WithMany("ArtistMetadata")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Artist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artwork", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Channel", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.FFmpegProfile", "FFmpegProfile")
+                        .WithMany()
+                        .HasForeignKey("FFmpegProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "FallbackFiller")
+                        .WithMany()
+                        .HasForeignKey("FallbackFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("FFmpegProfile");
+
+                    b.Navigation("FallbackFiller");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.CollectionItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany("CollectionItems")
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany("CollectionItems")
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Director", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyMediaSource", "EmbyMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("EmbyMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmbyMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyMediaSource", "EmbyMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("EmbyMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmbyMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", "Episode")
+                        .WithMany("EpisodeMetadata")
+                        .HasForeignKey("EpisodeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Episode");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.FFmpegProfile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Resolution", "Resolution")
+                        .WithMany()
+                        .HasForeignKey("ResolutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Resolution");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Filler.FillerPreset", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Genre", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinMediaSource", "JellyfinMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("JellyfinMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JellyfinMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinMediaSource", "JellyfinMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("JellyfinMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JellyfinMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", "MediaSource")
+                        .WithMany("Libraries")
+                        .HasForeignKey("MediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryFolder", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.LibraryPath", "LibraryPath")
+                        .WithMany("LibraryFolders")
+                        .HasForeignKey("LibraryPathId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LibraryPath");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", "Library")
+                        .WithMany("Paths")
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Library");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaChapter", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("Chapters")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaFile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("MediaFiles")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.LibraryPath", "LibraryPath")
+                        .WithMany("MediaItems")
+                        .HasForeignKey("LibraryPathId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LibraryPath");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaStream", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("Streams")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("EpisodeId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("MovieId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideo", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("MusicVideoId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideo", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("OtherVideoId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Song", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("SongId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MetadataGuid", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Mood", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Moods")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", "Movie")
+                        .WithMany("MovieMetadata")
+                        .HasForeignKey("MovieId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Movie");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany("MultiCollectionItems")
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany("MultiCollectionItems")
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MultiCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionSmartItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany("MultiCollectionSmartItems")
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany("MultiCollectionSmartItems")
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoArtist", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Artists")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideo", "MusicVideo")
+                        .WithMany("MusicVideoMetadata")
+                        .HasForeignKey("MusicVideoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MusicVideo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideo", "OtherVideo")
+                        .WithMany("OtherVideoMetadata")
+                        .HasForeignKey("OtherVideoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OtherVideo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Channel", "Channel")
+                        .WithMany("Playouts")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("Playouts")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.PlayoutAnchor", "Anchor", b1 =>
+                        {
+                            b1.Property<int>("PlayoutId")
+                                .HasColumnType("int");
+
+                            b1.Property<DateTime?>("DurationFinish")
+                                .HasColumnType("datetime(6)");
+
+                            b1.Property<bool>("InDurationFiller")
+                                .HasColumnType("tinyint(1)");
+
+                            b1.Property<bool>("InFlood")
+                                .HasColumnType("tinyint(1)");
+
+                            b1.Property<int?>("MultipleRemaining")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("NextGuideGroup")
+                                .HasColumnType("int");
+
+                            b1.Property<DateTime>("NextStart")
+                                .HasColumnType("datetime(6)");
+
+                            b1.HasKey("PlayoutId");
+
+                            b1.ToTable("PlayoutAnchor", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutId");
+
+                            b1.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "ScheduleItemsEnumeratorState", b2 =>
+                                {
+                                    b2.Property<int>("PlayoutAnchorPlayoutId")
+                                        .HasColumnType("int");
+
+                                    b2.Property<int>("Index")
+                                        .HasColumnType("int");
+
+                                    b2.Property<int>("Seed")
+                                        .HasColumnType("int");
+
+                                    b2.HasKey("PlayoutAnchorPlayoutId");
+
+                                    b2.ToTable("ScheduleItemsEnumeratorState", (string)null);
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("PlayoutAnchorPlayoutId");
+                                });
+
+                            b1.Navigation("ScheduleItemsEnumeratorState");
+                        });
+
+                    b.Navigation("Anchor");
+
+                    b.Navigation("Channel");
+
+                    b.Navigation("ProgramSchedule");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("Items")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutProgramScheduleAnchor", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("ProgramScheduleAnchors")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "EnumeratorState", b1 =>
+                        {
+                            b1.Property<int>("PlayoutProgramScheduleAnchorId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Index")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Seed")
+                                .HasColumnType("int");
+
+                            b1.HasKey("PlayoutProgramScheduleAnchorId");
+
+                            b1.ToTable("CollectionEnumeratorState", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutProgramScheduleAnchorId");
+                        });
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("EnumeratorState");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutScheduleItemFillGroupIndex", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("FillGroupIndices")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", "ProgramScheduleItem")
+                        .WithMany()
+                        .HasForeignKey("ProgramScheduleItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "EnumeratorState", b1 =>
+                        {
+                            b1.Property<int>("PlayoutScheduleItemFillGroupIndexId")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Index")
+                                .HasColumnType("int");
+
+                            b1.Property<int>("Seed")
+                                .HasColumnType("int");
+
+                            b1.HasKey("PlayoutScheduleItemFillGroupIndexId");
+
+                            b1.ToTable("FillGroupEnumeratorState", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutScheduleItemFillGroupIndexId");
+                        });
+
+                    b.Navigation("EnumeratorState");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("ProgramScheduleItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.PlexMediaSource", "PlexMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("PlexMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PlexMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.PlexMediaSource", "PlexMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("PlexMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PlexMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleAlternate", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("ProgramScheduleAlternates")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("ProgramScheduleAlternates")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("ProgramSchedule");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "FallbackFiller")
+                        .WithMany()
+                        .HasForeignKey("FallbackFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "MidRollFiller")
+                        .WithMany()
+                        .HasForeignKey("MidRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PostRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PostRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PreRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PreRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("Items")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "TailFiller")
+                        .WithMany()
+                        .HasForeignKey("TailFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("FallbackFiller");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MidRollFiller");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("PostRollFiller");
+
+                    b.Navigation("PreRollFiller");
+
+                    b.Navigation("ProgramSchedule");
+
+                    b.Navigation("SmartCollection");
+
+                    b.Navigation("TailFiller");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.BlockGroup", "BlockGroup")
+                        .WithMany("Blocks")
+                        .HasForeignKey("BlockGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BlockGroup");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("Items")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutHistory", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("PlayoutHistory")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("PlayoutHistory")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Playout");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutTemplate", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("Templates")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Template", "Template")
+                        .WithMany("PlayoutTemplates")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", "TemplateGroup")
+                        .WithMany("Templates")
+                        .HasForeignKey("TemplateGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TemplateGroup");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("TemplateItems")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Template", "Template")
+                        .WithMany("Items")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", "Season")
+                        .WithMany("SeasonMetadata")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", "Show")
+                        .WithMany("ShowMetadata")
+                        .HasForeignKey("ShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Song", "Song")
+                        .WithMany("SongMetadata")
+                        .HasForeignKey("SongId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Song");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Studio", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Style", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Styles")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Subtitle", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Tag", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany("TraktListItems")
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.TraktList", "TraktList")
+                        .WithMany("Items")
+                        .HasForeignKey("TraktListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("TraktList");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItemGuid", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.TraktListItem", "TraktListItem")
+                        .WithMany("Guids")
+                        .HasForeignKey("TraktListItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TraktListItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Writer", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Emby.EmbyPathInfo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyLibrary", null)
+                        .WithMany("PathInfos")
+                        .HasForeignKey("EmbyLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Jellyfin.JellyfinPathInfo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinLibrary", null)
+                        .WithMany("PathInfos")
+                        .HasForeignKey("JellyfinLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.LocalLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaFile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaFile", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMediaFile", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Artist", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Episode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Season", "Season")
+                        .WithMany("Episodes")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Movie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Artist", "Artist")
+                        .WithMany("MusicVideos")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.MusicVideo", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Artist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.OtherVideo", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Season", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Show", "Show")
+                        .WithMany("Seasons")
+                        .HasForeignKey("ShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Show", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Song", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.LocalMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemOne", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemOne", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbySeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbySeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinSeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinSeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexSeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexSeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Moods");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Styles");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Playouts");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Collection", b =>
+                {
+                    b.Navigation("CollectionItems");
+
+                    b.Navigation("MultiCollectionItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.Navigation("Paths");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.Navigation("LibraryFolders");
+
+                    b.Navigation("MediaItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.Navigation("CollectionItems");
+
+                    b.Navigation("TraktListItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaSource", b =>
+                {
+                    b.Navigation("Libraries");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.Navigation("Chapters");
+
+                    b.Navigation("MediaFiles");
+
+                    b.Navigation("Streams");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollection", b =>
+                {
+                    b.Navigation("MultiCollectionItems");
+
+                    b.Navigation("MultiCollectionSmartItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artists");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.Navigation("FillGroupIndices");
+
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutHistory");
+
+                    b.Navigation("ProgramScheduleAlternates");
+
+                    b.Navigation("ProgramScheduleAnchors");
+
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramSchedule", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Playouts");
+
+                    b.Navigation("ProgramScheduleAlternates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutHistory");
+
+                    b.Navigation("TemplateItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockGroup", b =>
+                {
+                    b.Navigation("Blocks");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutTemplates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", b =>
+                {
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SmartCollection", b =>
+                {
+                    b.Navigation("MultiCollectionSmartItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktList", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.Navigation("Guids");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.Navigation("PathInfos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.Navigation("PathInfos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.Navigation("ArtistMetadata");
+
+                    b.Navigation("MusicVideos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.Navigation("EpisodeMetadata");
+
+                    b.Navigation("MediaVersions");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("MovieMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("MusicVideoMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("OtherVideoMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.Navigation("Episodes");
+
+                    b.Navigation("SeasonMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.Navigation("Seasons");
+
+                    b.Navigation("ShowMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("SongMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/ErsatzTV.Infrastructure.MySql/Migrations/20240209170532_Reset_SongMetadataTagLib.cs b/ErsatzTV.Infrastructure.MySql/Migrations/20240209170532_Reset_SongMetadataTagLib.cs
new file mode 100644
index 000000000..b636fbe8a
--- /dev/null
+++ b/ErsatzTV.Infrastructure.MySql/Migrations/20240209170532_Reset_SongMetadataTagLib.cs
@@ -0,0 +1,34 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.MySql.Migrations
+{
+    /// <inheritdoc />
+    public partial class Reset_SongMetadataTagLib : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(
+                @"UPDATE LibraryPath SET LastScan = '0001-01-01 00:00:00' WHERE Id IN
+                (SELECT LP.Id FROM LibraryPath LP INNER JOIN Library L on L.Id = LP.LibraryId WHERE MediaKind = 5)");
+
+            migrationBuilder.Sql(
+                @"UPDATE Library SET LastScan = '0001-01-01 00:00:00' WHERE MediaKind = 5");
+
+            migrationBuilder.Sql(
+                @"UPDATE Artwork SET DateUpdated = '0001-01-01 00:00:00' WHERE SongMetadataId IS NOT NULL");
+            
+            migrationBuilder.Sql(
+                @"UPDATE LibraryFolder SET Etag = NULL WHERE Id IN
+                (SELECT LF.Id FROM LibraryFolder LF INNER JOIN LibraryPath LP on LF.LibraryPathId = LP.Id INNER JOIN Library L on LP.LibraryId = L.Id WHERE MediaKind = 5)");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}
diff --git a/ErsatzTV.Infrastructure.MySql/Migrations/TvContextModelSnapshot.cs b/ErsatzTV.Infrastructure.MySql/Migrations/TvContextModelSnapshot.cs
index cadad91db..95c819600 100644
--- a/ErsatzTV.Infrastructure.MySql/Migrations/TvContextModelSnapshot.cs
+++ b/ErsatzTV.Infrastructure.MySql/Migrations/TvContextModelSnapshot.cs
@@ -2190,13 +2190,13 @@ namespace ErsatzTV.Infrastructure.MySql.Migrations
                     b.Property<string>("Album")
                         .HasColumnType("longtext");
 
-                    b.Property<string>("AlbumArtist")
+                    b.Property<string>("AlbumArtists")
                         .HasColumnType("longtext");
 
-                    b.Property<string>("Artist")
+                    b.Property<string>("Artists")
                         .HasColumnType("longtext");
 
-                    b.Property<string>("Date")
+                    b.Property<string>("Comment")
                         .HasColumnType("longtext");
 
                     b.Property<DateTime>("DateAdded")
diff --git a/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209164734_Update_SongMetadataParity.Designer.cs b/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209164734_Update_SongMetadataParity.Designer.cs
new file mode 100644
index 000000000..b2b5cb362
--- /dev/null
+++ b/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209164734_Update_SongMetadataParity.Designer.cs
@@ -0,0 +1,4923 @@
+// <auto-generated />
+using System;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.Sqlite.Migrations
+{
+    [DbContext(typeof(TvContext))]
+    [Migration("20240209164734_Update_SongMetadataParity")]
+    partial class Update_SongMetadataParity
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.1");
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Actor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtworkId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Order")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("ArtworkId")
+                        .IsUnique();
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Actor", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ArtistId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Biography")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Disambiguation")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Formed")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("ArtistMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artwork", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ArtworkKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("BlurHash43")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("BlurHash54")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("BlurHash64")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SourcePath")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("ChannelId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Artwork", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Categories")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("FFmpegProfileId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("FallbackFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Group")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("ErsatzTV");
+
+                    b.Property<int>("MusicVideoCreditsMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MusicVideoCreditsTemplate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("StreamingMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SubtitleMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("UniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FFmpegProfileId");
+
+                    b.HasIndex("FallbackFillerId");
+
+                    b.HasIndex("Number")
+                        .IsUnique();
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("Channel", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ChannelWatermark", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("DurationSeconds")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("FrequencyMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("HorizontalMarginPercent")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Image")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ImageSource")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Location")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Mode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Opacity")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("PlaceWithinSourceContent")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Size")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VerticalMarginPercent")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("WidthPercent")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ChannelWatermark", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Collection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("UseCustomPlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Collection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.CollectionItem", b =>
+                {
+                    b.Property<int>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("CustomIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("CollectionId", "MediaItemId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.ToTable("CollectionItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ConfigElement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key")
+                        .IsUnique();
+
+                    b.ToTable("ConfigElement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Director", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.ToTable("Director", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmbyCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("EmbyMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyMediaSourceId");
+
+                    b.ToTable("EmbyConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("EmbyMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("EmbyPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyMediaSourceId");
+
+                    b.ToTable("EmbyPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("EpisodeId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("EpisodeNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeId");
+
+                    b.ToTable("EpisodeMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.FFmpegProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioBitrate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioBufferSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioChannels")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioFormat")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioSampleRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BitDepth")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("DeinterlaceVideo")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("HardwareAcceleration")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("NormalizeFramerate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.Property<int>("NormalizeLoudnessMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("QsvExtraHardwareFrames")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ResolutionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ScalingBehavior")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ThreadCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("VaapiDevice")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("VaapiDriver")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VideoBitrate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VideoBufferSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VideoFormat")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ResolutionId");
+
+                    b.ToTable("FFmpegProfile", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Filler.FillerPreset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("AllowWatermarks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Count")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan?>("Duration")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("FillerKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("FillerMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("PadToNearestMinute")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("FillerPreset", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Genre", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Genre");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("JellyfinCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("JellyfinMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinMediaSourceId");
+
+                    b.ToTable("JellyfinConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("JellyfinMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("JellyfinPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinMediaSourceId");
+
+                    b.ToTable("JellyfinPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LanguageCode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("EnglishName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FrenchName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ThreeCode1")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ThreeCode2")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TwoCode")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LanguageCode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaSourceId");
+
+                    b.ToTable("Library", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryFolder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LibraryPathId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryPathId");
+
+                    b.ToTable("LibraryFolder", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LibraryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryId");
+
+                    b.ToTable("LibraryPath", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaChapter", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("ChapterId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.ToTable("MediaChapter", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.HasIndex("Path")
+                        .IsUnique();
+
+                    b.ToTable("MediaFile", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LibraryPathId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("State")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryPathId");
+
+                    b.ToTable("MediaItem", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MediaSource", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaStream", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("AttachedPic")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BitsPerRawSample")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Channels")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorPrimaries")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorRange")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorSpace")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorTransfer")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Default")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Forced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaStreamKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MimeType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PixelFormat")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Profile")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.ToTable("MediaStream", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DisplayAspectRatio")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeSpan>("Duration")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("EpisodeId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("RFrameRate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SampleAspectRatio")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SongId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VideoScanKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeId");
+
+                    b.HasIndex("MovieId");
+
+                    b.HasIndex("MusicVideoId");
+
+                    b.HasIndex("OtherVideoId");
+
+                    b.HasIndex("SongId");
+
+                    b.ToTable("MediaVersion", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MetadataGuid", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("MetadataGuid", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Mood", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.ToTable("Mood");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MovieId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MovieId");
+
+                    b.ToTable("MovieMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MultiCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionItem", b =>
+                {
+                    b.Property<int>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ScheduleAsGroup")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("MultiCollectionId", "CollectionId");
+
+                    b.HasIndex("CollectionId");
+
+                    b.ToTable("MultiCollectionItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionSmartItem", b =>
+                {
+                    b.Property<int>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SmartCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ScheduleAsGroup")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("MultiCollectionId", "SmartCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("MultiCollectionSmartItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoArtist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.ToTable("MusicVideoArtist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MusicVideoId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Track")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MusicVideoId");
+
+                    b.ToTable("MusicVideoMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("OtherVideoId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OtherVideoId");
+
+                    b.ToTable("OtherVideoMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan?>("DailyRebuildTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalJsonFile")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ProgramScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProgramSchedulePlayoutType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Seed")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.ToTable("Playout", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("BlockKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChapterTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CollectionEtag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CollectionKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CustomTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("DisableWatermarks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("FillerKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("Finish")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("GuideFinish")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("GuideGroup")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("InPoint")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("OutPoint")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("Start")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SubtitleMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("PlayoutItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutProgramScheduleAnchor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("AnchorDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FakeCollectionKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("PlayoutProgramScheduleAnchor", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutScheduleItemFillGroupIndex", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProgramScheduleItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("ProgramScheduleItemId");
+
+                    b.ToTable("PlayoutScheduleItemFillGroupIndex", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PlexCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlexMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Uri")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexMediaSourceId");
+
+                    b.ToTable("PlexConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlexMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PlexPath")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexMediaSourceId");
+
+                    b.ToTable("PlexPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("KeepMultiPartEpisodesTogether")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("RandomStartPoint")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShuffleScheduleItems")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("TreatCollectionsAsShows")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ProgramSchedule", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleAlternate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("DaysOfMonth")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DaysOfWeek")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MonthsOfYear")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.ToTable("ProgramScheduleAlternate", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CustomTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FakeCollectionKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("FallbackFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("FillWithGroupMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("GuideMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MidRollFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("PostRollFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("PreRollFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SubtitleMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("TailFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("FallbackFillerId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MidRollFillerId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("PostRollFillerId");
+
+                    b.HasIndex("PreRollFillerId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.HasIndex("TailFillerId");
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("ProgramScheduleItem", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Resolution", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsCustom")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Resolution", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BlockGroupId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Minutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("StopScheduling")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockGroupId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Block", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("BlockGroup", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("BlockItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Details")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("When")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.ToTable("PlayoutHistory", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutTemplate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DaysOfMonth")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DaysOfWeek")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("EndDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MonthsOfYear")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("StartDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("PlayoutTemplate", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TemplateGroupId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("TemplateGroupId");
+
+                    b.ToTable("Template", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("TemplateGroup", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("TemplateItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SeasonId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("SeasonMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ShowId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ShowId");
+
+                    b.ToTable("ShowMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SmartCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Query")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SmartCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AlbumArtists")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Artists")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SongId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Track")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SongId");
+
+                    b.ToTable("SongMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Studio", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Studio", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Style", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.ToTable("Style");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Subtitle", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Default")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Forced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsExtracted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Language")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("SDH")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SubtitleKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Subtitle", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Tag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ExternalCollectionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Tag");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktList", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ItemCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("List")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TraktId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("User")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TraktList", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Episode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Rank")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Season")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TraktId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TraktListId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("TraktListId");
+
+                    b.ToTable("TraktListItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItemGuid", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TraktListItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TraktListItemId");
+
+                    b.ToTable("TraktListItemGuid", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Writer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.ToTable("Writer", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Emby.EmbyPathInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EmbyLibraryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("NetworkPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyLibraryId");
+
+                    b.ToTable("EmbyPathInfo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Jellyfin.JellyfinPathInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("JellyfinLibraryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("NetworkPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinLibraryId");
+
+                    b.ToTable("JellyfinPathInfo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("EmbyLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("JellyfinLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.ToTable("LocalLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("PlexLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaFile", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaFile");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlexId")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("PlexMediaFile", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Artist", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("SeasonId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("Episode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Movie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("ArtistId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("MusicVideo", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("OtherVideo", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("SeasonNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ShowId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasIndex("ShowId");
+
+                    b.ToTable("Season", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Show", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Song", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OperatingSystem")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("EmbyMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OperatingSystem")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("JellyfinMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.ToTable("LocalMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<string>("ClientIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Platform")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlatformVersion")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProductVersion")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.Property<int>("DiscardToFillAttempts")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("PlayoutDuration")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TailMode")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("ProgramScheduleDurationItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.ToTable("ProgramScheduleFloodItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.Property<int>("Count")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("ProgramScheduleMultipleItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemOne", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.ToTable("ProgramScheduleOneItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("EmbyEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("JellyfinEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("EmbyMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("JellyfinMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbySeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("EmbySeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinSeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("JellyfinSeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexSeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexSeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("EmbyShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("JellyfinShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Actor", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Artwork", "Artwork")
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Actor", "ArtworkId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Artwork");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Artist", "Artist")
+                        .WithMany("ArtistMetadata")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Artist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artwork", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Channel", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.FFmpegProfile", "FFmpegProfile")
+                        .WithMany()
+                        .HasForeignKey("FFmpegProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "FallbackFiller")
+                        .WithMany()
+                        .HasForeignKey("FallbackFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("FFmpegProfile");
+
+                    b.Navigation("FallbackFiller");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.CollectionItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany("CollectionItems")
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany("CollectionItems")
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Director", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyMediaSource", "EmbyMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("EmbyMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmbyMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyMediaSource", "EmbyMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("EmbyMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmbyMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", "Episode")
+                        .WithMany("EpisodeMetadata")
+                        .HasForeignKey("EpisodeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Episode");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.FFmpegProfile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Resolution", "Resolution")
+                        .WithMany()
+                        .HasForeignKey("ResolutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Resolution");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Filler.FillerPreset", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Genre", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinMediaSource", "JellyfinMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("JellyfinMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JellyfinMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinMediaSource", "JellyfinMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("JellyfinMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JellyfinMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", "MediaSource")
+                        .WithMany("Libraries")
+                        .HasForeignKey("MediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryFolder", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.LibraryPath", "LibraryPath")
+                        .WithMany("LibraryFolders")
+                        .HasForeignKey("LibraryPathId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LibraryPath");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", "Library")
+                        .WithMany("Paths")
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Library");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaChapter", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("Chapters")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaFile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("MediaFiles")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.LibraryPath", "LibraryPath")
+                        .WithMany("MediaItems")
+                        .HasForeignKey("LibraryPathId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LibraryPath");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaStream", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("Streams")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("EpisodeId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("MovieId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideo", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("MusicVideoId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideo", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("OtherVideoId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Song", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("SongId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MetadataGuid", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Mood", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Moods")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", "Movie")
+                        .WithMany("MovieMetadata")
+                        .HasForeignKey("MovieId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Movie");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany("MultiCollectionItems")
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany("MultiCollectionItems")
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MultiCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionSmartItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany("MultiCollectionSmartItems")
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany("MultiCollectionSmartItems")
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoArtist", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Artists")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideo", "MusicVideo")
+                        .WithMany("MusicVideoMetadata")
+                        .HasForeignKey("MusicVideoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MusicVideo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideo", "OtherVideo")
+                        .WithMany("OtherVideoMetadata")
+                        .HasForeignKey("OtherVideoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OtherVideo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Channel", "Channel")
+                        .WithMany("Playouts")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("Playouts")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.PlayoutAnchor", "Anchor", b1 =>
+                        {
+                            b1.Property<int>("PlayoutId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<DateTime?>("DurationFinish")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<bool>("InDurationFiller")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<bool>("InFlood")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int?>("MultipleRemaining")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("NextGuideGroup")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<DateTime>("NextStart")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("PlayoutId");
+
+                            b1.ToTable("PlayoutAnchor", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutId");
+
+                            b1.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "ScheduleItemsEnumeratorState", b2 =>
+                                {
+                                    b2.Property<int>("PlayoutAnchorPlayoutId")
+                                        .HasColumnType("INTEGER");
+
+                                    b2.Property<int>("Index")
+                                        .HasColumnType("INTEGER");
+
+                                    b2.Property<int>("Seed")
+                                        .HasColumnType("INTEGER");
+
+                                    b2.HasKey("PlayoutAnchorPlayoutId");
+
+                                    b2.ToTable("ScheduleItemsEnumeratorState", (string)null);
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("PlayoutAnchorPlayoutId");
+                                });
+
+                            b1.Navigation("ScheduleItemsEnumeratorState");
+                        });
+
+                    b.Navigation("Anchor");
+
+                    b.Navigation("Channel");
+
+                    b.Navigation("ProgramSchedule");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("Items")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutProgramScheduleAnchor", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("ProgramScheduleAnchors")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "EnumeratorState", b1 =>
+                        {
+                            b1.Property<int>("PlayoutProgramScheduleAnchorId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Index")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Seed")
+                                .HasColumnType("INTEGER");
+
+                            b1.HasKey("PlayoutProgramScheduleAnchorId");
+
+                            b1.ToTable("CollectionEnumeratorState", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutProgramScheduleAnchorId");
+                        });
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("EnumeratorState");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutScheduleItemFillGroupIndex", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("FillGroupIndices")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", "ProgramScheduleItem")
+                        .WithMany()
+                        .HasForeignKey("ProgramScheduleItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "EnumeratorState", b1 =>
+                        {
+                            b1.Property<int>("PlayoutScheduleItemFillGroupIndexId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Index")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Seed")
+                                .HasColumnType("INTEGER");
+
+                            b1.HasKey("PlayoutScheduleItemFillGroupIndexId");
+
+                            b1.ToTable("FillGroupEnumeratorState", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutScheduleItemFillGroupIndexId");
+                        });
+
+                    b.Navigation("EnumeratorState");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("ProgramScheduleItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.PlexMediaSource", "PlexMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("PlexMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PlexMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.PlexMediaSource", "PlexMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("PlexMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PlexMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleAlternate", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("ProgramScheduleAlternates")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("ProgramScheduleAlternates")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("ProgramSchedule");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "FallbackFiller")
+                        .WithMany()
+                        .HasForeignKey("FallbackFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "MidRollFiller")
+                        .WithMany()
+                        .HasForeignKey("MidRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PostRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PostRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PreRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PreRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("Items")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "TailFiller")
+                        .WithMany()
+                        .HasForeignKey("TailFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("FallbackFiller");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MidRollFiller");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("PostRollFiller");
+
+                    b.Navigation("PreRollFiller");
+
+                    b.Navigation("ProgramSchedule");
+
+                    b.Navigation("SmartCollection");
+
+                    b.Navigation("TailFiller");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.BlockGroup", "BlockGroup")
+                        .WithMany("Blocks")
+                        .HasForeignKey("BlockGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BlockGroup");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("Items")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutHistory", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("PlayoutHistory")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("PlayoutHistory")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Playout");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutTemplate", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("Templates")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Template", "Template")
+                        .WithMany("PlayoutTemplates")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", "TemplateGroup")
+                        .WithMany("Templates")
+                        .HasForeignKey("TemplateGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TemplateGroup");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("TemplateItems")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Template", "Template")
+                        .WithMany("Items")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", "Season")
+                        .WithMany("SeasonMetadata")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", "Show")
+                        .WithMany("ShowMetadata")
+                        .HasForeignKey("ShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Song", "Song")
+                        .WithMany("SongMetadata")
+                        .HasForeignKey("SongId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Song");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Studio", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Style", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Styles")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Subtitle", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Tag", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany("TraktListItems")
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.TraktList", "TraktList")
+                        .WithMany("Items")
+                        .HasForeignKey("TraktListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("TraktList");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItemGuid", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.TraktListItem", "TraktListItem")
+                        .WithMany("Guids")
+                        .HasForeignKey("TraktListItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TraktListItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Writer", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Emby.EmbyPathInfo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyLibrary", null)
+                        .WithMany("PathInfos")
+                        .HasForeignKey("EmbyLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Jellyfin.JellyfinPathInfo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinLibrary", null)
+                        .WithMany("PathInfos")
+                        .HasForeignKey("JellyfinLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.LocalLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaFile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaFile", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMediaFile", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Artist", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Episode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Season", "Season")
+                        .WithMany("Episodes")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Movie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Artist", "Artist")
+                        .WithMany("MusicVideos")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.MusicVideo", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Artist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.OtherVideo", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Season", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Show", "Show")
+                        .WithMany("Seasons")
+                        .HasForeignKey("ShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Show", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Song", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.LocalMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemOne", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemOne", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbySeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbySeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinSeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinSeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexSeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexSeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Moods");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Styles");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Playouts");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Collection", b =>
+                {
+                    b.Navigation("CollectionItems");
+
+                    b.Navigation("MultiCollectionItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.Navigation("Paths");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.Navigation("LibraryFolders");
+
+                    b.Navigation("MediaItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.Navigation("CollectionItems");
+
+                    b.Navigation("TraktListItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaSource", b =>
+                {
+                    b.Navigation("Libraries");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.Navigation("Chapters");
+
+                    b.Navigation("MediaFiles");
+
+                    b.Navigation("Streams");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollection", b =>
+                {
+                    b.Navigation("MultiCollectionItems");
+
+                    b.Navigation("MultiCollectionSmartItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artists");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.Navigation("FillGroupIndices");
+
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutHistory");
+
+                    b.Navigation("ProgramScheduleAlternates");
+
+                    b.Navigation("ProgramScheduleAnchors");
+
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramSchedule", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Playouts");
+
+                    b.Navigation("ProgramScheduleAlternates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutHistory");
+
+                    b.Navigation("TemplateItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockGroup", b =>
+                {
+                    b.Navigation("Blocks");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutTemplates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", b =>
+                {
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SmartCollection", b =>
+                {
+                    b.Navigation("MultiCollectionSmartItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktList", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.Navigation("Guids");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.Navigation("PathInfos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.Navigation("PathInfos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.Navigation("ArtistMetadata");
+
+                    b.Navigation("MusicVideos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.Navigation("EpisodeMetadata");
+
+                    b.Navigation("MediaVersions");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("MovieMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("MusicVideoMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("OtherVideoMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.Navigation("Episodes");
+
+                    b.Navigation("SeasonMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.Navigation("Seasons");
+
+                    b.Navigation("ShowMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("SongMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209164734_Update_SongMetadataParity.cs b/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209164734_Update_SongMetadataParity.cs
new file mode 100644
index 000000000..e8cc5a7e7
--- /dev/null
+++ b/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209164734_Update_SongMetadataParity.cs
@@ -0,0 +1,48 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.Sqlite.Migrations
+{
+    /// <inheritdoc />
+    public partial class Update_SongMetadataParity : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "Date",
+                table: "SongMetadata",
+                newName: "Comment");
+
+            migrationBuilder.RenameColumn(
+                name: "Artist",
+                table: "SongMetadata",
+                newName: "Artists");
+
+            migrationBuilder.RenameColumn(
+                name: "AlbumArtist",
+                table: "SongMetadata",
+                newName: "AlbumArtists");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "Comment",
+                table: "SongMetadata",
+                newName: "Date");
+
+            migrationBuilder.RenameColumn(
+                name: "Artists",
+                table: "SongMetadata",
+                newName: "Artist");
+
+            migrationBuilder.RenameColumn(
+                name: "AlbumArtists",
+                table: "SongMetadata",
+                newName: "AlbumArtist");
+        }
+    }
+}
diff --git a/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209170434_Reset_SongMetadataTagLib.Designer.cs b/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209170434_Reset_SongMetadataTagLib.Designer.cs
new file mode 100644
index 000000000..75aa4f6a6
--- /dev/null
+++ b/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209170434_Reset_SongMetadataTagLib.Designer.cs
@@ -0,0 +1,4923 @@
+// <auto-generated />
+using System;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.Sqlite.Migrations
+{
+    [DbContext(typeof(TvContext))]
+    [Migration("20240209170434_Reset_SongMetadataTagLib")]
+    partial class Reset_SongMetadataTagLib
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "8.0.1");
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Actor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtworkId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Order")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("ArtworkId")
+                        .IsUnique();
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Actor", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ArtistId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Biography")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Disambiguation")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Formed")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("ArtistMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artwork", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ArtworkKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("BlurHash43")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("BlurHash54")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("BlurHash64")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SourcePath")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("ChannelId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Artwork", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Categories")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("FFmpegProfileId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("FallbackFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Group")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .HasDefaultValue("ErsatzTV");
+
+                    b.Property<int>("MusicVideoCreditsMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MusicVideoCreditsTemplate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Number")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("StreamingMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SubtitleMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("UniqueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FFmpegProfileId");
+
+                    b.HasIndex("FallbackFillerId");
+
+                    b.HasIndex("Number")
+                        .IsUnique();
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("Channel", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ChannelWatermark", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("DurationSeconds")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("FrequencyMinutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("HorizontalMarginPercent")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Image")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ImageSource")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Location")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Mode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Opacity")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("PlaceWithinSourceContent")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Size")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VerticalMarginPercent")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("WidthPercent")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ChannelWatermark", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Collection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("UseCustomPlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Collection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.CollectionItem", b =>
+                {
+                    b.Property<int>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("CustomIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("CollectionId", "MediaItemId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.ToTable("CollectionItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ConfigElement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key")
+                        .IsUnique();
+
+                    b.ToTable("ConfigElement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Director", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.ToTable("Director", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EmbyCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("EmbyMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyMediaSourceId");
+
+                    b.ToTable("EmbyConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("EmbyMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("EmbyPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyMediaSourceId");
+
+                    b.ToTable("EmbyPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("EpisodeId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("EpisodeNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeId");
+
+                    b.ToTable("EpisodeMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.FFmpegProfile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioBitrate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioBufferSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioChannels")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioFormat")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("AudioSampleRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BitDepth")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("DeinterlaceVideo")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(true);
+
+                    b.Property<int>("HardwareAcceleration")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("NormalizeFramerate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.Property<int>("NormalizeLoudnessMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("QsvExtraHardwareFrames")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ResolutionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ScalingBehavior")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ThreadCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("VaapiDevice")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("VaapiDriver")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VideoBitrate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VideoBufferSize")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VideoFormat")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ResolutionId");
+
+                    b.ToTable("FFmpegProfile", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Filler.FillerPreset", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("AllowWatermarks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Count")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan?>("Duration")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("FillerKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("FillerMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("PadToNearestMinute")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("FillerPreset", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Genre", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Genre");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("JellyfinCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Address")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("JellyfinMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinMediaSourceId");
+
+                    b.ToTable("JellyfinConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("JellyfinMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("JellyfinPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinMediaSourceId");
+
+                    b.ToTable("JellyfinPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LanguageCode", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("EnglishName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FrenchName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ThreeCode1")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ThreeCode2")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("TwoCode")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("LanguageCode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaSourceId");
+
+                    b.ToTable("Library", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryFolder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LibraryPathId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryPathId");
+
+                    b.ToTable("LibraryFolder", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LibraryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryId");
+
+                    b.ToTable("LibraryPath", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaChapter", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("ChapterId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.ToTable("MediaChapter", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaFile", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.HasIndex("Path")
+                        .IsUnique();
+
+                    b.ToTable("MediaFile", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("LibraryPathId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("State")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LibraryPathId");
+
+                    b.ToTable("MediaItem", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MediaSource", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaStream", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("AttachedPic")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BitsPerRawSample")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Channels")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorPrimaries")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorRange")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorSpace")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorTransfer")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Default")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FileName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Forced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaStreamKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MediaVersionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MimeType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PixelFormat")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Profile")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaVersionId");
+
+                    b.ToTable("MediaStream", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DisplayAspectRatio")
+                        .HasColumnType("TEXT");
+
+                    b.Property<TimeSpan>("Duration")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("EpisodeId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("RFrameRate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SampleAspectRatio")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SongId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("VideoScanKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeId");
+
+                    b.HasIndex("MovieId");
+
+                    b.HasIndex("MusicVideoId");
+
+                    b.HasIndex("OtherVideoId");
+
+                    b.HasIndex("SongId");
+
+                    b.ToTable("MediaVersion", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MetadataGuid", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("MetadataGuid", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Mood", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.ToTable("Mood");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MovieId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MovieId");
+
+                    b.ToTable("MovieMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MultiCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionItem", b =>
+                {
+                    b.Property<int>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ScheduleAsGroup")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("MultiCollectionId", "CollectionId");
+
+                    b.HasIndex("CollectionId");
+
+                    b.ToTable("MultiCollectionItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionSmartItem", b =>
+                {
+                    b.Property<int>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SmartCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ScheduleAsGroup")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("MultiCollectionId", "SmartCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("MultiCollectionSmartItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoArtist", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.ToTable("MusicVideoArtist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MusicVideoId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Track")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MusicVideoId");
+
+                    b.ToTable("MusicVideoMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("OtherVideoId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OtherVideoId");
+
+                    b.ToTable("OtherVideoMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChannelId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan?>("DailyRebuildTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalJsonFile")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ProgramScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProgramSchedulePlayoutType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Seed")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ChannelId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.ToTable("Playout", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("BlockKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ChapterTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CollectionEtag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CollectionKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CustomTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("DisableWatermarks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("FillerKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("Finish")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("GuideFinish")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("GuideGroup")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("InPoint")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("OutPoint")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("Start")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SubtitleMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("PlayoutItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutProgramScheduleAnchor", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("AnchorDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("FakeCollectionKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("PlayoutProgramScheduleAnchor", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutScheduleItemFillGroupIndex", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProgramScheduleItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("ProgramScheduleItemId");
+
+                    b.ToTable("PlayoutScheduleItemFillGroupIndex", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PlexCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlexMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Uri")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexMediaSourceId");
+
+                    b.ToTable("PlexConnection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexPathReplacement", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("LocalPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlexMediaSourceId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PlexPath")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlexMediaSourceId");
+
+                    b.ToTable("PlexPathReplacement", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("KeepMultiPartEpisodesTogether")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("RandomStartPoint")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShuffleScheduleItems")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("TreatCollectionsAsShows")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ProgramSchedule", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleAlternate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("DaysOfMonth")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DaysOfWeek")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MonthsOfYear")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.ToTable("ProgramScheduleAlternate", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CustomTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("FakeCollectionKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("FallbackFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("FillWithGroupMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("GuideMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MidRollFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("PostRollFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("PreRollFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("PreferredAudioLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredAudioTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredSubtitleLanguageCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ProgramScheduleId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan?>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SubtitleMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("TailFillerId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("WatermarkId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("FallbackFillerId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MidRollFillerId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("PostRollFillerId");
+
+                    b.HasIndex("PreRollFillerId");
+
+                    b.HasIndex("ProgramScheduleId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.HasIndex("TailFillerId");
+
+                    b.HasIndex("WatermarkId");
+
+                    b.ToTable("ProgramScheduleItem", (string)null);
+
+                    b.UseTptMappingStrategy();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Resolution", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsCustom")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Resolution", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BlockGroupId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Minutes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("StopScheduling")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockGroupId");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("Block", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("BlockGroup", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("CollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("CollectionType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MultiCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SmartCollectionId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("CollectionId");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("MultiCollectionId");
+
+                    b.HasIndex("SmartCollectionId");
+
+                    b.ToTable("BlockItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutHistory", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Details")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlaybackOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("When")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.ToTable("PlayoutHistory", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutTemplate", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DaysOfMonth")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DaysOfWeek")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTimeOffset>("EndDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("MonthsOfYear")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlayoutId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTimeOffset>("StartDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PlayoutId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("PlayoutTemplate", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TemplateGroupId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("TemplateGroupId");
+
+                    b.ToTable("Template", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("TemplateGroup", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("BlockId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("StartTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BlockId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.ToTable("TemplateItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SeasonId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("SeasonMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ContentRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Outline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Plot")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ShowId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ShowId");
+
+                    b.ToTable("ShowMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SmartCollection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Query")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SmartCollection", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AlbumArtists")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Artists")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MetadataKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ReleaseDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SongId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Track")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SongId");
+
+                    b.ToTable("SongMetadata", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Studio", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Studio", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Style", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.ToTable("Style");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Subtitle", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateUpdated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Default")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Forced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsExtracted")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.Property<string>("Language")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("SDH")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false);
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SubtitleKind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Subtitle", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Tag", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ArtistMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ExternalCollectionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MusicVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SeasonMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ShowMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SongMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ArtistMetadataId");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("MusicVideoMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.HasIndex("SeasonMetadataId");
+
+                    b.HasIndex("ShowMetadataId");
+
+                    b.HasIndex("SongMetadataId");
+
+                    b.ToTable("Tag");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktList", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ItemCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("List")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TraktId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("User")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("TraktList", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Episode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MediaItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Rank")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Season")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TraktId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TraktListId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Year")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("MediaItemId");
+
+                    b.HasIndex("TraktListId");
+
+                    b.ToTable("TraktListItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItemGuid", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TraktListItemId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TraktListItemId");
+
+                    b.ToTable("TraktListItemGuid", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Writer", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EpisodeMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MovieMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("OtherVideoMetadataId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EpisodeMetadataId");
+
+                    b.HasIndex("MovieMetadataId");
+
+                    b.HasIndex("OtherVideoMetadataId");
+
+                    b.ToTable("Writer", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Emby.EmbyPathInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("EmbyLibraryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("NetworkPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EmbyLibraryId");
+
+                    b.ToTable("EmbyPathInfo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Jellyfin.JellyfinPathInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("JellyfinLibraryId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("NetworkPath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("JellyfinLibraryId");
+
+                    b.ToTable("JellyfinPathInfo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("EmbyLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("JellyfinLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.ToTable("LocalLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexLibrary", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Library");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("ShouldSyncItems")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("PlexLibrary", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaFile", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaFile");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("PlexId")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("PlexMediaFile", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Artist", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("SeasonId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasIndex("SeasonId");
+
+                    b.ToTable("Episode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Movie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("ArtistId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasIndex("ArtistId");
+
+                    b.ToTable("MusicVideo", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("OtherVideo", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.Property<int>("SeasonNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ShowId")
+                        .HasColumnType("INTEGER");
+
+                    b.HasIndex("ShowId");
+
+                    b.ToTable("Season", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Show", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaItem");
+
+                    b.ToTable("Song", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OperatingSystem")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("EmbyMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OperatingSystem")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("JellyfinMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.ToTable("LocalMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.MediaSource");
+
+                    b.Property<string>("ClientIdentifier")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastCollectionsScan")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Platform")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PlatformVersion")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProductVersion")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ServerName")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexMediaSource", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.Property<int>("DiscardToFillAttempts")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<TimeSpan>("PlayoutDuration")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("TailMode")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("ProgramScheduleDurationItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.ToTable("ProgramScheduleFloodItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.Property<int>("Count")
+                        .HasColumnType("INTEGER");
+
+                    b.ToTable("ProgramScheduleMultipleItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemOne", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.ProgramScheduleItem");
+
+                    b.ToTable("ProgramScheduleOneItem", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("EmbyEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("JellyfinEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexEpisode", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Episode");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexEpisode", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("EmbyMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("JellyfinMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMovie", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Movie");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexMovie", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbySeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("EmbySeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinSeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("JellyfinSeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexSeason", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Season");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexSeason", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("EmbyShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("JellyfinShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexShow", b =>
+                {
+                    b.HasBaseType("ErsatzTV.Core.Domain.Show");
+
+                    b.Property<string>("Etag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT");
+
+                    b.ToTable("PlexShow", (string)null);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Actor", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Artwork", "Artwork")
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Actor", "ArtworkId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Actors")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Artwork");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Artist", "Artist")
+                        .WithMany("ArtistMetadata")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Artist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artwork", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Channel", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Artwork")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.FFmpegProfile", "FFmpegProfile")
+                        .WithMany()
+                        .HasForeignKey("FFmpegProfileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "FallbackFiller")
+                        .WithMany()
+                        .HasForeignKey("FallbackFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("FFmpegProfile");
+
+                    b.Navigation("FallbackFiller");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.CollectionItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany("CollectionItems")
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany("CollectionItems")
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Director", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Directors")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyMediaSource", "EmbyMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("EmbyMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmbyMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyMediaSource", "EmbyMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("EmbyMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("EmbyMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", "Episode")
+                        .WithMany("EpisodeMetadata")
+                        .HasForeignKey("EpisodeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Episode");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.FFmpegProfile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Resolution", "Resolution")
+                        .WithMany()
+                        .HasForeignKey("ResolutionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Resolution");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Filler.FillerPreset", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Genre", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Genres")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinMediaSource", "JellyfinMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("JellyfinMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JellyfinMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinMediaSource", "JellyfinMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("JellyfinMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("JellyfinMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", "MediaSource")
+                        .WithMany("Libraries")
+                        .HasForeignKey("MediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryFolder", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.LibraryPath", "LibraryPath")
+                        .WithMany("LibraryFolders")
+                        .HasForeignKey("LibraryPathId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LibraryPath");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", "Library")
+                        .WithMany("Paths")
+                        .HasForeignKey("LibraryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Library");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaChapter", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("Chapters")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaFile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("MediaFiles")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.LibraryPath", "LibraryPath")
+                        .WithMany("MediaItems")
+                        .HasForeignKey("LibraryPathId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("LibraryPath");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaStream", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaVersion", "MediaVersion")
+                        .WithMany("Streams")
+                        .HasForeignKey("MediaVersionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaVersion");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("EpisodeId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("MovieId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideo", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("MusicVideoId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideo", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("OtherVideoId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Song", null)
+                        .WithMany("MediaVersions")
+                        .HasForeignKey("SongId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MetadataGuid", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Guids")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Mood", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Moods")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", "Movie")
+                        .WithMany("MovieMetadata")
+                        .HasForeignKey("MovieId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Movie");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany("MultiCollectionItems")
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany("MultiCollectionItems")
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MultiCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollectionSmartItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany("MultiCollectionSmartItems")
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany("MultiCollectionSmartItems")
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoArtist", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Artists")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideo", "MusicVideo")
+                        .WithMany("MusicVideoMetadata")
+                        .HasForeignKey("MusicVideoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MusicVideo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideo", "OtherVideo")
+                        .WithMany("OtherVideoMetadata")
+                        .HasForeignKey("OtherVideoId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OtherVideo");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Channel", "Channel")
+                        .WithMany("Playouts")
+                        .HasForeignKey("ChannelId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("Playouts")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.PlayoutAnchor", "Anchor", b1 =>
+                        {
+                            b1.Property<int>("PlayoutId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<DateTime?>("DurationFinish")
+                                .HasColumnType("TEXT");
+
+                            b1.Property<bool>("InDurationFiller")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<bool>("InFlood")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int?>("MultipleRemaining")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("NextGuideGroup")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<DateTime>("NextStart")
+                                .HasColumnType("TEXT");
+
+                            b1.HasKey("PlayoutId");
+
+                            b1.ToTable("PlayoutAnchor", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutId");
+
+                            b1.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "ScheduleItemsEnumeratorState", b2 =>
+                                {
+                                    b2.Property<int>("PlayoutAnchorPlayoutId")
+                                        .HasColumnType("INTEGER");
+
+                                    b2.Property<int>("Index")
+                                        .HasColumnType("INTEGER");
+
+                                    b2.Property<int>("Seed")
+                                        .HasColumnType("INTEGER");
+
+                                    b2.HasKey("PlayoutAnchorPlayoutId");
+
+                                    b2.ToTable("ScheduleItemsEnumeratorState", (string)null);
+
+                                    b2.WithOwner()
+                                        .HasForeignKey("PlayoutAnchorPlayoutId");
+                                });
+
+                            b1.Navigation("ScheduleItemsEnumeratorState");
+                        });
+
+                    b.Navigation("Anchor");
+
+                    b.Navigation("Channel");
+
+                    b.Navigation("ProgramSchedule");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("Items")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutProgramScheduleAnchor", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("ProgramScheduleAnchors")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "EnumeratorState", b1 =>
+                        {
+                            b1.Property<int>("PlayoutProgramScheduleAnchorId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Index")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Seed")
+                                .HasColumnType("INTEGER");
+
+                            b1.HasKey("PlayoutProgramScheduleAnchorId");
+
+                            b1.ToTable("CollectionEnumeratorState", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutProgramScheduleAnchorId");
+                        });
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("EnumeratorState");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlayoutScheduleItemFillGroupIndex", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("FillGroupIndices")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", "ProgramScheduleItem")
+                        .WithMany()
+                        .HasForeignKey("ProgramScheduleItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.OwnsOne("ErsatzTV.Core.Domain.CollectionEnumeratorState", "EnumeratorState", b1 =>
+                        {
+                            b1.Property<int>("PlayoutScheduleItemFillGroupIndexId")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Index")
+                                .HasColumnType("INTEGER");
+
+                            b1.Property<int>("Seed")
+                                .HasColumnType("INTEGER");
+
+                            b1.HasKey("PlayoutScheduleItemFillGroupIndexId");
+
+                            b1.ToTable("FillGroupEnumeratorState", (string)null);
+
+                            b1.WithOwner()
+                                .HasForeignKey("PlayoutScheduleItemFillGroupIndexId");
+                        });
+
+                    b.Navigation("EnumeratorState");
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("ProgramScheduleItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexConnection", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.PlexMediaSource", "PlexMediaSource")
+                        .WithMany("Connections")
+                        .HasForeignKey("PlexMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PlexMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexPathReplacement", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.PlexMediaSource", "PlexMediaSource")
+                        .WithMany("PathReplacements")
+                        .HasForeignKey("PlexMediaSourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PlexMediaSource");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleAlternate", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("ProgramScheduleAlternates")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("ProgramScheduleAlternates")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("ProgramSchedule");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "FallbackFiller")
+                        .WithMany()
+                        .HasForeignKey("FallbackFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "MidRollFiller")
+                        .WithMany()
+                        .HasForeignKey("MidRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PostRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PostRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "PreRollFiller")
+                        .WithMany()
+                        .HasForeignKey("PreRollFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramSchedule", "ProgramSchedule")
+                        .WithMany("Items")
+                        .HasForeignKey("ProgramScheduleId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.Filler.FillerPreset", "TailFiller")
+                        .WithMany()
+                        .HasForeignKey("TailFillerId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ChannelWatermark", "Watermark")
+                        .WithMany()
+                        .HasForeignKey("WatermarkId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("FallbackFiller");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MidRollFiller");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("PostRollFiller");
+
+                    b.Navigation("PreRollFiller");
+
+                    b.Navigation("ProgramSchedule");
+
+                    b.Navigation("SmartCollection");
+
+                    b.Navigation("TailFiller");
+
+                    b.Navigation("Watermark");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.BlockGroup", "BlockGroup")
+                        .WithMany("Blocks")
+                        .HasForeignKey("BlockGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BlockGroup");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("Items")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Collection", "Collection")
+                        .WithMany()
+                        .HasForeignKey("CollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany()
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MultiCollection", "MultiCollection")
+                        .WithMany()
+                        .HasForeignKey("MultiCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SmartCollection", "SmartCollection")
+                        .WithMany()
+                        .HasForeignKey("SmartCollectionId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Collection");
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("MultiCollection");
+
+                    b.Navigation("SmartCollection");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutHistory", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("PlayoutHistory")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("PlayoutHistory")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Playout");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.PlayoutTemplate", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Playout", "Playout")
+                        .WithMany("Templates")
+                        .HasForeignKey("PlayoutId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Template", "Template")
+                        .WithMany("PlayoutTemplates")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Playout");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", "TemplateGroup")
+                        .WithMany("Templates")
+                        .HasForeignKey("TemplateGroupId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TemplateGroup");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Block", "Block")
+                        .WithMany("TemplateItems")
+                        .HasForeignKey("BlockId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Scheduling.Template", "Template")
+                        .WithMany("Items")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Block");
+
+                    b.Navigation("Template");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", "Season")
+                        .WithMany("SeasonMetadata")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", "Show")
+                        .WithMany("ShowMetadata")
+                        .HasForeignKey("ShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Song", "Song")
+                        .WithMany("SongMetadata")
+                        .HasForeignKey("SongId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Song");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Studio", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Studios")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Style", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Styles")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Subtitle", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Subtitles")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Tag", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ArtistMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ArtistMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MusicVideoMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("MusicVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SeasonMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("SeasonMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.ShowMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("ShowMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.SongMetadata", null)
+                        .WithMany("Tags")
+                        .HasForeignKey("SongMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", "MediaItem")
+                        .WithMany("TraktListItems")
+                        .HasForeignKey("MediaItemId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ErsatzTV.Core.Domain.TraktList", "TraktList")
+                        .WithMany("Items")
+                        .HasForeignKey("TraktListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MediaItem");
+
+                    b.Navigation("TraktList");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItemGuid", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.TraktListItem", "TraktListItem")
+                        .WithMany("Guids")
+                        .HasForeignKey("TraktListItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TraktListItem");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Writer", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EpisodeMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("EpisodeMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.MovieMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("MovieMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.HasOne("ErsatzTV.Core.Domain.OtherVideoMetadata", null)
+                        .WithMany("Writers")
+                        .HasForeignKey("OtherVideoMetadataId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Emby.EmbyPathInfo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.EmbyLibrary", null)
+                        .WithMany("PathInfos")
+                        .HasForeignKey("EmbyLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Jellyfin.JellyfinPathInfo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.JellyfinLibrary", null)
+                        .WithMany("PathInfos")
+                        .HasForeignKey("JellyfinLibraryId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.LocalLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexLibrary", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Library", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexLibrary", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaFile", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaFile", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMediaFile", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Artist", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Episode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Season", "Season")
+                        .WithMany("Episodes")
+                        .HasForeignKey("SeasonId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Season");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Movie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Artist", "Artist")
+                        .WithMany("MusicVideos")
+                        .HasForeignKey("ArtistId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.MusicVideo", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Artist");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.OtherVideo", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Season", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ErsatzTV.Core.Domain.Show", "Show")
+                        .WithMany("Seasons")
+                        .HasForeignKey("ShowId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Show");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Show", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.Song", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LocalMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.LocalMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.MediaSource", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMediaSource", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemDuration", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemFlood", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemMultiple", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramScheduleItemOne", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.ProgramScheduleItem", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.ProgramScheduleItemOne", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexEpisode", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Episode", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexEpisode", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMovie", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Movie", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexMovie", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbySeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbySeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinSeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinSeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexSeason", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Season", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexSeason", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.EmbyShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.JellyfinShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexShow", b =>
+                {
+                    b.HasOne("ErsatzTV.Core.Domain.Show", null)
+                        .WithOne()
+                        .HasForeignKey("ErsatzTV.Core.Domain.PlexShow", "Id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ArtistMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Moods");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Styles");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Channel", b =>
+                {
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Playouts");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Collection", b =>
+                {
+                    b.Navigation("CollectionItems");
+
+                    b.Navigation("MultiCollectionItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EpisodeMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Library", b =>
+                {
+                    b.Navigation("Paths");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.LibraryPath", b =>
+                {
+                    b.Navigation("LibraryFolders");
+
+                    b.Navigation("MediaItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaItem", b =>
+                {
+                    b.Navigation("CollectionItems");
+
+                    b.Navigation("TraktListItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaSource", b =>
+                {
+                    b.Navigation("Libraries");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MediaVersion", b =>
+                {
+                    b.Navigation("Chapters");
+
+                    b.Navigation("MediaFiles");
+
+                    b.Navigation("Streams");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MovieMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MultiCollection", b =>
+                {
+                    b.Navigation("MultiCollectionItems");
+
+                    b.Navigation("MultiCollectionSmartItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideoMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artists");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideoMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Directors");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+
+                    b.Navigation("Writers");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Playout", b =>
+                {
+                    b.Navigation("FillGroupIndices");
+
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutHistory");
+
+                    b.Navigation("ProgramScheduleAlternates");
+
+                    b.Navigation("ProgramScheduleAnchors");
+
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ProgramSchedule", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("Playouts");
+
+                    b.Navigation("ProgramScheduleAlternates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Block", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutHistory");
+
+                    b.Navigation("TemplateItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.BlockGroup", b =>
+                {
+                    b.Navigation("Blocks");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.Template", b =>
+                {
+                    b.Navigation("Items");
+
+                    b.Navigation("PlayoutTemplates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Scheduling.TemplateGroup", b =>
+                {
+                    b.Navigation("Templates");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SeasonMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.ShowMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SmartCollection", b =>
+                {
+                    b.Navigation("MultiCollectionSmartItems");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.SongMetadata", b =>
+                {
+                    b.Navigation("Actors");
+
+                    b.Navigation("Artwork");
+
+                    b.Navigation("Genres");
+
+                    b.Navigation("Guids");
+
+                    b.Navigation("Studios");
+
+                    b.Navigation("Subtitles");
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktList", b =>
+                {
+                    b.Navigation("Items");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.TraktListItem", b =>
+                {
+                    b.Navigation("Guids");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyLibrary", b =>
+                {
+                    b.Navigation("PathInfos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinLibrary", b =>
+                {
+                    b.Navigation("PathInfos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Artist", b =>
+                {
+                    b.Navigation("ArtistMetadata");
+
+                    b.Navigation("MusicVideos");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Episode", b =>
+                {
+                    b.Navigation("EpisodeMetadata");
+
+                    b.Navigation("MediaVersions");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Movie", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("MovieMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.MusicVideo", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("MusicVideoMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.OtherVideo", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("OtherVideoMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Season", b =>
+                {
+                    b.Navigation("Episodes");
+
+                    b.Navigation("SeasonMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Show", b =>
+                {
+                    b.Navigation("Seasons");
+
+                    b.Navigation("ShowMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.Song", b =>
+                {
+                    b.Navigation("MediaVersions");
+
+                    b.Navigation("SongMetadata");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.EmbyMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.JellyfinMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+
+            modelBuilder.Entity("ErsatzTV.Core.Domain.PlexMediaSource", b =>
+                {
+                    b.Navigation("Connections");
+
+                    b.Navigation("PathReplacements");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209170434_Reset_SongMetadataTagLib.cs b/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209170434_Reset_SongMetadataTagLib.cs
new file mode 100644
index 000000000..7e625ec27
--- /dev/null
+++ b/ErsatzTV.Infrastructure.Sqlite/Migrations/20240209170434_Reset_SongMetadataTagLib.cs
@@ -0,0 +1,34 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ErsatzTV.Infrastructure.Sqlite.Migrations
+{
+    /// <inheritdoc />
+    public partial class Reset_SongMetadataTagLib : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql(
+                @"UPDATE LibraryPath SET LastScan = '0001-01-01 00:00:00' WHERE Id IN
+                (SELECT LP.Id FROM LibraryPath LP INNER JOIN Library L on L.Id = LP.LibraryId WHERE MediaKind = 5)");
+
+            migrationBuilder.Sql(
+                @"UPDATE Library SET LastScan = '0001-01-01 00:00:00' WHERE MediaKind = 5");
+
+            migrationBuilder.Sql(
+                @"UPDATE Artwork SET DateUpdated = '0001-01-01 00:00:00' WHERE SongMetadataId IS NOT NULL");
+            
+            migrationBuilder.Sql(
+                @"UPDATE LibraryFolder SET Etag = NULL WHERE Id IN
+                (SELECT LF.Id FROM LibraryFolder LF INNER JOIN LibraryPath LP on LF.LibraryPathId = LP.Id INNER JOIN Library L on LP.LibraryId = L.Id WHERE MediaKind = 5)");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}
diff --git a/ErsatzTV.Infrastructure.Sqlite/Migrations/TvContextModelSnapshot.cs b/ErsatzTV.Infrastructure.Sqlite/Migrations/TvContextModelSnapshot.cs
index 07b484658..c269082a8 100644
--- a/ErsatzTV.Infrastructure.Sqlite/Migrations/TvContextModelSnapshot.cs
+++ b/ErsatzTV.Infrastructure.Sqlite/Migrations/TvContextModelSnapshot.cs
@@ -2188,13 +2188,13 @@ namespace ErsatzTV.Infrastructure.Sqlite.Migrations
                     b.Property<string>("Album")
                         .HasColumnType("TEXT");
 
-                    b.Property<string>("AlbumArtist")
+                    b.Property<string>("AlbumArtists")
                         .HasColumnType("TEXT");
 
-                    b.Property<string>("Artist")
+                    b.Property<string>("Artists")
                         .HasColumnType("TEXT");
 
-                    b.Property<string>("Date")
+                    b.Property<string>("Comment")
                         .HasColumnType("TEXT");
 
                     b.Property<DateTime>("DateAdded")
diff --git a/ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs b/ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs
index eb2df5219..3f5fb01e0 100644
--- a/ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs
+++ b/ErsatzTV.Infrastructure/Data/Repositories/MediaCollectionRepository.cs
@@ -397,7 +397,7 @@ public class MediaCollectionRepository : IMediaCollectionRepository
 
         var allArtists = items.OfType<Song>()
             .SelectMany(s => s.SongMetadata)
-            .Map(sm => sm.AlbumArtist)
+            .Map(sm => sm.AlbumArtists.HeadOrNone().Match(aa => aa, string.Empty))
             .Distinct()
             .ToList();
 
@@ -409,11 +409,16 @@ public class MediaCollectionRepository : IMediaCollectionRepository
         var songArtistCollections = new Dictionary<int, List<MediaItem>>();
         foreach (Song song in items.OfType<Song>())
         {
-            int key = allArtists.IndexOf(song.SongMetadata.HeadOrNone().Match(sm => sm.AlbumArtist, string.Empty));
+            string firstArtist = song.SongMetadata
+                .SelectMany(sm => sm.AlbumArtists)
+                .HeadOrNone()
+                .Match(aa => aa, string.Empty);
+
+            int key = allArtists.IndexOf(firstArtist);
 
             List<MediaItem> list = songArtistCollections.TryGetValue(key, out List<MediaItem> collection)
                 ? collection
-                : new List<MediaItem>();
+                : [];
 
             if (list.All(i => i.Id != song.Id))
             {
diff --git a/ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj b/ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj
index 278ea5878..f4f97c269 100644
--- a/ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj
+++ b/ErsatzTV.Infrastructure/ErsatzTV.Infrastructure.csproj
@@ -32,6 +32,7 @@
       <PackageReference Include="Refit.Newtonsoft.Json" Version="7.0.0" />
       <PackageReference Include="Refit.Xml" Version="7.0.0" />
       <PackageReference Include="Scriban.Signed" Version="5.9.1" />
+      <PackageReference Include="TagLibSharp" Version="2.3.0" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/ErsatzTV.Infrastructure/Metadata/LocalStatisticsProvider.cs b/ErsatzTV.Infrastructure/Metadata/LocalStatisticsProvider.cs
index 572607217..512f9d189 100644
--- a/ErsatzTV.Infrastructure/Metadata/LocalStatisticsProvider.cs
+++ b/ErsatzTV.Infrastructure/Metadata/LocalStatisticsProvider.cs
@@ -11,8 +11,10 @@ using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Extensions;
 using ErsatzTV.Core.Interfaces.Metadata;
 using ErsatzTV.Core.Interfaces.Repositories;
+using Lucene.Net.Util.Fst;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
+using File = TagLib.File;
 
 namespace ErsatzTV.Infrastructure.Metadata;
 
@@ -61,111 +63,44 @@ public class LocalStatisticsProvider : ILocalStatisticsProvider
         }
     }
 
-    public async Task<Either<BaseError, Dictionary<string, string>>> GetSongTags(
-        string ffprobePath,
-        MediaItem mediaItem)
+    public Either<BaseError, List<SongTag>> GetSongTags(string ffprobePath, MediaItem mediaItem)
     {
         try
         {
-            string mediaItemPath = mediaItem.GetHeadVersion().MediaFiles.Head().Path;
-            Either<BaseError, FFprobe> maybeProbe = await GetProbeOutput(ffprobePath, mediaItemPath);
-            foreach (BaseError error in maybeProbe.LeftToSeq())
-            {
-                return error;
-            }
 
-            Option<FFprobeTags> maybeFormatTags = maybeProbe.RightToSeq()
-                .Map(p => p?.format?.tags ?? FFprobeTags.Empty)
-                .HeadOrNone();
+            string mediaItemPath = mediaItem.GetHeadVersion().MediaFiles.Head().Path;
+            var song = File.Create(mediaItemPath);
 
-            Option<FFprobeTags> maybeAudioTags = maybeProbe.RightToSeq()
-                .Bind(p => p.streams.Filter(s => s.codec_type == "audio").HeadOrNone())
-                .Map(s => s.tags ?? FFprobeTags.Empty)
-                .HeadOrNone();
+            var result = new List<SongTag>();
 
-            foreach (FFprobeTags formatTags in maybeFormatTags)
-            foreach (FFprobeTags audioTags in maybeAudioTags)
+            // album
+            if (!string.IsNullOrWhiteSpace(song.Tag.Album))
             {
-                var result = new Dictionary<string, string>();
-
-                // album
-                if (!string.IsNullOrWhiteSpace(formatTags.album))
-                {
-                    result.Add(MetadataSongTag.Album, formatTags.album);
-                }
-                else if (!string.IsNullOrWhiteSpace(audioTags.album))
-                {
-                    result.Add(MetadataSongTag.Album, audioTags.album);
-                }
-
-                // album artist
-                if (!string.IsNullOrWhiteSpace(formatTags.albumArtist))
-                {
-                    result.Add(MetadataSongTag.AlbumArtist, formatTags.albumArtist);
-                }
-                else if (!string.IsNullOrWhiteSpace(audioTags.albumArtist))
-                {
-                    result.Add(MetadataSongTag.AlbumArtist, audioTags.albumArtist);
-                }
-
-                // artist
-                if (!string.IsNullOrWhiteSpace(formatTags.artist))
-                {
-                    result.Add(MetadataSongTag.Artist, formatTags.artist);
-
-                    // if no album artist is present, use the track artist
-                    result.TryAdd(MetadataSongTag.AlbumArtist, formatTags.artist);
-                }
-                else if (!string.IsNullOrWhiteSpace(audioTags.artist))
-                {
-                    result.Add(MetadataSongTag.Artist, audioTags.artist);
-
-                    // if no album artist is present, use the track artist
-                    result.TryAdd(MetadataSongTag.AlbumArtist, audioTags.artist);
-                }
-
-                // date
-                if (!string.IsNullOrWhiteSpace(formatTags.date))
-                {
-                    result.Add(MetadataSongTag.Date, formatTags.date);
-                }
-                else if (!string.IsNullOrWhiteSpace(audioTags.date))
-                {
-                    result.Add(MetadataSongTag.Date, audioTags.date);
-                }
-
-                // genre
-                if (!string.IsNullOrWhiteSpace(formatTags.genre))
-                {
-                    result.Add(MetadataSongTag.Genre, formatTags.genre);
-                }
-                else if (!string.IsNullOrWhiteSpace(audioTags.genre))
-                {
-                    result.Add(MetadataSongTag.Genre, audioTags.genre);
-                }
-
-                // title
-                if (!string.IsNullOrWhiteSpace(formatTags.title))
-                {
-                    result.Add(MetadataSongTag.Title, formatTags.title);
-                }
-                else if (!string.IsNullOrWhiteSpace(audioTags.title))
-                {
-                    result.Add(MetadataSongTag.Title, audioTags.title);
-                }
-
-                // track
-                if (!string.IsNullOrWhiteSpace(formatTags.track))
-                {
-                    result.Add(MetadataSongTag.Track, formatTags.track);
-                }
-                else if (!string.IsNullOrWhiteSpace(audioTags.track))
-                {
-                    result.Add(MetadataSongTag.Track, audioTags.track);
-                }
-
-                return result;
+                result.Add(new SongTag(MetadataSongTag.Album, song.Tag.Album));
+            }
+            
+            // album artist(s)
+            IEnumerable<string> albumArtists = song.Tag.AlbumArtists.Filter(a => !string.IsNullOrWhiteSpace(a));
+            result.AddRange(albumArtists.Map(albumArtist => new SongTag(MetadataSongTag.AlbumArtist, albumArtist)));
+            
+            // artist(s)
+            IEnumerable<string> artists = song.Tag.Performers.Filter(p => !string.IsNullOrWhiteSpace(p));
+            result.AddRange(artists.Map(artist => new SongTag(MetadataSongTag.Artist, artist)));
+
+            // genre(s)
+            IEnumerable<string> genres = song.Tag.Genres.Filter(g => !string.IsNullOrWhiteSpace(g));
+            result.AddRange(genres.Map(genre => new SongTag(MetadataSongTag.Genre, genre)));
+
+            // title
+            if (!string.IsNullOrWhiteSpace(song.Tag.Title))
+            {
+                result.Add(new SongTag(MetadataSongTag.Title, song.Tag.Title));
             }
+            
+            // track
+            result.Add(new SongTag(MetadataSongTag.Track, song.Tag.Track.ToString(CultureInfo.InvariantCulture)));
+
+            return result;
         }
         catch (Exception ex)
         {
@@ -173,8 +108,6 @@ public class LocalStatisticsProvider : ILocalStatisticsProvider
             _client.Notify(ex);
             return BaseError.New(ex.Message);
         }
-
-        return BaseError.New("BUG - this should never happen");
     }
 
     private async Task<Either<BaseError, bool>> RefreshStatistics(
diff --git a/ErsatzTV.Infrastructure/Metadata/MetadataSongTag.cs b/ErsatzTV.Infrastructure/Metadata/MetadataSongTag.cs
index 4e696f0d9..00c0b4d08 100644
--- a/ErsatzTV.Infrastructure/Metadata/MetadataSongTag.cs
+++ b/ErsatzTV.Infrastructure/Metadata/MetadataSongTag.cs
@@ -2,11 +2,12 @@
 
 public static class MetadataSongTag
 {
-    public static readonly string Album = "album";
-    public static readonly string Artist = "artist";
-    public static readonly string AlbumArtist = "albumartist";
-    public static readonly string Date = "date";
-    public static readonly string Genre = "genre";
-    public static readonly string Title = "title";
-    public static readonly string Track = "track";
+    public const string Album = "album";
+    public const string Artist = "artist";
+    public const string AlbumArtist = "albumartist";
+    public const string Date = "date";
+    public const string Genre = "genre";
+    public const string Title = "title";
+    public const string Track = "track";
+    public const string Comment = "comment";
 }
diff --git a/ErsatzTV.Infrastructure/Search/ElasticSearchIndex.cs b/ErsatzTV.Infrastructure/Search/ElasticSearchIndex.cs
index 3a6fb5150..85da1d09a 100644
--- a/ErsatzTV.Infrastructure/Search/ElasticSearchIndex.cs
+++ b/ErsatzTV.Infrastructure/Search/ElasticSearchIndex.cs
@@ -46,7 +46,7 @@ public class ElasticSearchIndex : ISearchIndex
         return exists.IsValidResponse;
     }
 
-    public int Version => 40;
+    public int Version => 41;
 
     public async Task<bool> Initialize(
         ILocalFileSystem localFileSystem,
@@ -703,8 +703,8 @@ public class ElasticSearchIndex : ISearchIndex
                     SubLanguageTag = GetSubLanguageTags(song.MediaVersions),
                     AddedDate = GetAddedDate(metadata.DateAdded),
                     Album = metadata.Album ?? string.Empty,
-                    Artist = !string.IsNullOrWhiteSpace(metadata.Artist) ? new List<string> { metadata.Artist } : null,
-                    AlbumArtist = metadata.AlbumArtist,
+                    Artist = metadata.Artists.ToList(),
+                    AlbumArtist = metadata.AlbumArtists.ToList(),
                     Genre = metadata.Genres.Map(g => g.Name).ToList(),
                     Tag = metadata.Tags.Map(t => t.Name).ToList()
                 };
diff --git a/ErsatzTV.Infrastructure/Search/LuceneSearchIndex.cs b/ErsatzTV.Infrastructure/Search/LuceneSearchIndex.cs
index a2c2a1eb2..c7d1db609 100644
--- a/ErsatzTV.Infrastructure/Search/LuceneSearchIndex.cs
+++ b/ErsatzTV.Infrastructure/Search/LuceneSearchIndex.cs
@@ -111,7 +111,7 @@ public sealed class LuceneSearchIndex : ISearchIndex
         return Task.FromResult(directoryExists && fileExists);
     }
 
-    public int Version => 40;
+    public int Version => 41;
 
     public async Task<bool> Initialize(
         ILocalFileSystem localFileSystem,
@@ -1238,14 +1238,14 @@ public sealed class LuceneSearchIndex : ISearchIndex
                     doc.Add(new TextField(AlbumField, metadata.Album, Field.Store.NO));
                 }
 
-                if (!string.IsNullOrWhiteSpace(metadata.Artist))
+                foreach (string artist in metadata.Artists)
                 {
-                    doc.Add(new TextField(ArtistField, metadata.Artist, Field.Store.NO));
+                    doc.Add(new TextField(ArtistField, artist, Field.Store.NO));
                 }
-
-                if (!string.IsNullOrWhiteSpace(metadata.AlbumArtist))
+                
+                foreach (string albumArtist in metadata.AlbumArtists)
                 {
-                    doc.Add(new TextField(AlbumArtistField, metadata.AlbumArtist, Field.Store.NO));
+                    doc.Add(new TextField(AlbumArtistField, albumArtist, Field.Store.NO));
                 }
 
                 foreach (Tag tag in metadata.Tags)
diff --git a/ErsatzTV.Infrastructure/Search/Models/ElasticSearchItem.cs b/ErsatzTV.Infrastructure/Search/Models/ElasticSearchItem.cs
index e70b49cf6..2b741841e 100644
--- a/ErsatzTV.Infrastructure/Search/Models/ElasticSearchItem.cs
+++ b/ErsatzTV.Infrastructure/Search/Models/ElasticSearchItem.cs
@@ -71,7 +71,7 @@ public class ElasticSearchItem : MinimalElasticSearchItem
     public string Album { get; set; }
 
     [JsonPropertyName(LuceneSearchIndex.AlbumArtistField)]
-    public string AlbumArtist { get; set; }
+    public List<string> AlbumArtist { get; set; }
 
     [JsonPropertyName(LuceneSearchIndex.PlotField)]
     public string Plot { get; set; }
diff --git a/ErsatzTV.Scanner.Tests/Core/FFmpeg/TranscodingTests.cs b/ErsatzTV.Scanner.Tests/Core/FFmpeg/TranscodingTests.cs
index 33c5dc422..b39540cbd 100644
--- a/ErsatzTV.Scanner.Tests/Core/FFmpeg/TranscodingTests.cs
+++ b/ErsatzTV.Scanner.Tests/Core/FFmpeg/TranscodingTests.cs
@@ -25,8 +25,6 @@ using ErsatzTV.FFmpeg.State;
 using ErsatzTV.Infrastructure.Images;
 using ErsatzTV.Infrastructure.Metadata;
 using ErsatzTV.Infrastructure.Runtime;
-using ErsatzTV.Scanner.Core.Interfaces.Metadata;
-using ErsatzTV.Scanner.Core.Metadata;
 using FluentAssertions;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
@@ -290,16 +288,16 @@ public class TranscodingTests
 
         var song = new Song
         {
-            SongMetadata = new List<SongMetadata>
-            {
-                new()
+            SongMetadata =
+            [
+                new SongMetadata
                 {
                     Title = "Song Title",
-                    Artist = "Song Artist",
-                    Artwork = new List<Artwork>()
+                    Artists = ["Song Artist"],
+                    Artwork = []
                 }
-            },
-            MediaVersions = new List<MediaVersion> { songVersion }
+            ],
+            MediaVersions = [songVersion]
         };
 
         (string videoPath, MediaVersion videoVersion) = await songVideoGenerator.GenerateSongVideo(
diff --git a/ErsatzTV.Scanner/Core/Metadata/LocalMetadataProvider.cs b/ErsatzTV.Scanner/Core/Metadata/LocalMetadataProvider.cs
index 6ab6a48b5..0d05782af 100644
--- a/ErsatzTV.Scanner/Core/Metadata/LocalMetadataProvider.cs
+++ b/ErsatzTV.Scanner/Core/Metadata/LocalMetadataProvider.cs
@@ -198,7 +198,7 @@ public class LocalMetadataProvider : ILocalMetadataProvider
 
     public async Task<bool> RefreshTagMetadata(Song song, string ffprobePath)
     {
-        Option<SongMetadata> maybeMetadata = await LoadSongMetadata(song, ffprobePath);
+        Option<SongMetadata> maybeMetadata = LoadSongMetadata(song, ffprobePath);
         foreach (SongMetadata metadata in maybeMetadata)
         {
             return await ApplyMetadataUpdate(song, metadata);
@@ -296,19 +296,17 @@ public class LocalMetadataProvider : ILocalMetadataProvider
         }
     }
 
-    private async Task<Option<SongMetadata>> LoadSongMetadata(Song song, string ffprobePath)
+    private Option<SongMetadata> LoadSongMetadata(Song song, string ffprobePath)
     {
         string path = song.GetHeadVersion().MediaFiles.Head().Path;
 
         try
         {
-            Either<BaseError, Dictionary<string, string>> maybeTags =
-                await _localStatisticsProvider.GetSongTags(ffprobePath, song);
+            var maybeTags = _localStatisticsProvider.GetSongTags(ffprobePath, song);
 
-            foreach (Dictionary<string, string> tags in maybeTags.RightToSeq())
+            foreach (List<SongTag> tags in maybeTags.RightToSeq())
             {
-                Option<SongMetadata> maybeFallbackMetadata =
-                    _fallbackMetadataProvider.GetFallbackMetadata(song);
+                Option<SongMetadata> maybeFallbackMetadata = _fallbackMetadataProvider.GetFallbackMetadata(song);
 
                 var result = new SongMetadata
                 {
@@ -316,46 +314,42 @@ public class LocalMetadataProvider : ILocalMetadataProvider
                     DateAdded = DateTime.UtcNow,
                     DateUpdated = File.GetLastWriteTimeUtc(path),
 
-                    Artwork = new List<Artwork>(),
-                    Actors = new List<Actor>(),
-                    Genres = new List<Genre>(),
-                    Studios = new List<Studio>(),
-                    Tags = new List<Tag>()
-                };
-
-                if (tags.TryGetValue(MetadataSongTag.Album, out string? album))
-                {
-                    result.Album = album;
-                }
-
-                if (tags.TryGetValue(MetadataSongTag.Artist, out string? artist))
-                {
-                    result.Artist = artist;
-                }
-
-                if (tags.TryGetValue(MetadataSongTag.AlbumArtist, out string? albumArtist))
-                {
-                    result.AlbumArtist = albumArtist;
-                }
+                    Artists = [],
+                    AlbumArtists = [],
 
-                if (tags.TryGetValue(MetadataSongTag.Date, out string? date))
-                {
-                    result.Date = date;
-                }
-
-                if (tags.TryGetValue(MetadataSongTag.Genre, out string? genre))
-                {
-                    result.Genres.AddRange(SplitGenres(genre).Map(n => new Genre { Name = n }));
-                }
-
-                if (tags.TryGetValue(MetadataSongTag.Title, out string? title))
-                {
-                    result.Title = title;
-                }
+                    Artwork = [],
+                    Actors = [],
+                    Genres = [],
+                    Studios = [],
+                    Tags = []
+                };
 
-                if (tags.TryGetValue(MetadataSongTag.Track, out string? track))
+                foreach (SongTag tag in tags)
                 {
-                    result.Track = track;
+                    switch (tag.Tag)
+                    {
+                        case MetadataSongTag.Album:
+                            result.Album = tag.Value;
+                            break;
+                        case MetadataSongTag.Artist:
+                            result.Artists.Add(tag.Value);
+                            break;
+                        case MetadataSongTag.AlbumArtist:
+                            result.AlbumArtists.Add(tag.Value);
+                            break;
+                        case MetadataSongTag.Genre:
+                            result.Genres.Add(new Genre { Name = tag.Value });
+                            break;
+                        case MetadataSongTag.Title:
+                            result.Title = tag.Value;
+                            break;
+                        case MetadataSongTag.Track:
+                            result.Track = tag.Value;
+                            break;
+                        case MetadataSongTag.Comment:
+                            result.Comment = tag.Value;
+                            break;
+                    }
                 }
 
                 foreach (SongMetadata fallbackMetadata in maybeFallbackMetadata)
@@ -981,11 +975,11 @@ public class LocalMetadataProvider : ILocalMetadataProvider
         foreach (SongMetadata existing in maybeMetadata)
         {
             existing.Title = metadata.Title;
-            existing.Artist = metadata.Artist;
-            existing.AlbumArtist = metadata.AlbumArtist;
+            existing.Artists = metadata.Artists;
+            existing.AlbumArtists = metadata.AlbumArtists;
             existing.Album = metadata.Album;
-            existing.Date = metadata.Date;
             existing.Track = metadata.Track;
+            existing.Comment = metadata.Comment;
 
             if (existing.DateAdded == SystemTime.MinValueUtc)
             {
diff --git a/ErsatzTV/ErsatzTV.csproj b/ErsatzTV/ErsatzTV.csproj
index cf74ae959..3f8cc5617 100644
--- a/ErsatzTV/ErsatzTV.csproj
+++ b/ErsatzTV/ErsatzTV.csproj
@@ -77,6 +77,8 @@
       <EmbeddedResource Include="Resources\Templates\_episode.sbntxt" />
       <EmbeddedResource Include="Resources\Templates\_movie.sbntxt" />
       <EmbeddedResource Include="Resources\Templates\_musicVideo.sbntxt" />
+      <EmbeddedResource Include="Resources\Templates\_otherVideo.sbntxt" />
+      <EmbeddedResource Include="Resources\Templates\_song.sbntxt" />
     </ItemGroup>
 
     <ItemGroup>
diff --git a/ErsatzTV/Resources/Templates/_otherVideo.sbntxt b/ErsatzTV/Resources/Templates/_otherVideo.sbntxt
new file mode 100644
index 000000000..822d43845
--- /dev/null
+++ b/ErsatzTV/Resources/Templates/_otherVideo.sbntxt
@@ -0,0 +1,52 @@
+{{ ##
+
+Available values:
+  - programme_start
+  - programme_stop
+  - channel_number
+  - has_custom_title
+  - custom_title
+  - other_video_title
+  - other_video_has_plot
+  - other_video_plot
+  - other_video_has_year
+  - other_video_year
+  - other_video_genres
+  - other_video_has_content_rating
+  - other_video_content_rating
+ 
+The resulting XML will be minified by ErsatzTV - so feel free to keep things nicely formatted here.
+
+## }}
+
+<programme start="{{ programme_start }}" stop="{{ programme_stop }}" channel="{{ channel_number }}.etv">
+  {{ if has_custom_title }}
+      <title lang="en">{{ custom_title }}</title>
+  {{ else }}
+      <title lang="en">{{ other_video_title }}</title>
+      {{ if other_video_has_plot }}
+        <desc lang="en">{{ other_video_plot }}</desc>
+      {{ end }}
+      {{ if other_video_has_year }}
+        <date>{{ other_video_year }}</date>
+      {{ end }}
+      {{ for genre in other_video_genres }}
+        <category lang="en">{{ genre }}</category>
+      {{ end }}
+      {{ if movie_has_artwork }}
+        <icon src="{{ movie_artwork_url }}" />
+      {{ end }}
+  {{ end }}
+  {{ if other_video_has_content_rating }}
+    {{ for rating in other_video_content_rating | string.split '/' }}
+        {{ if rating | string.starts_with 'us:' }}
+          <rating system="MPAA"> 
+        {{ else }}
+          <rating>
+        {{ end }}
+          <value>{{ rating | string.replace 'us:' '' }}</value>
+        </rating>
+    {{ end }}
+  {{ end }}
+  <previously-shown />
+</programme>
diff --git a/ErsatzTV/Resources/Templates/_song.sbntxt b/ErsatzTV/Resources/Templates/_song.sbntxt
new file mode 100644
index 000000000..38c4ab943
--- /dev/null
+++ b/ErsatzTV/Resources/Templates/_song.sbntxt
@@ -0,0 +1,49 @@
+{{ ##
+
+Available values:
+  - programme_start
+  - programme_stop
+  - channel_number
+  - has_custom_title
+  - custom_title
+  - song_title
+  - song_artists
+  - song_album_artists
+  - song_has_year
+  - song_year
+  - song_genres
+  - song_has_artwork
+  - song_artwork_url
+  - song_has_track
+  - song_track
+  - song_has_comment
+  - song_comment
+  - song_has_album
+  - song_album
+  - song_has_release_date
+  - song_release_date
+  - song_studios
+ 
+The resulting XML will be minified by ErsatzTV - so feel free to keep things nicely formatted here.
+
+## }}
+
+<programme start="{{ programme_start }}" stop="{{ programme_stop }}" channel="{{ channel_number }}.etv">
+  {{ if has_custom_title }}
+      <title lang="en">{{ custom_title }}</title>
+  {{ else }}
+      <title lang="en">{{ song_artists | array.join ', ' }}</title>
+      <sub-title lang="en">{{ song_title }}</sub-title>
+      {{ if song_has_year }}
+        <date>{{ song_year }}</date>
+      {{ end }}
+      <category lang="en">Music</category>
+      {{ for genre in song_genres }}
+        <category lang="en">{{ genre }}</category>
+      {{ end }}
+      {{ if song_has_artwork }}
+        <icon src="{{ song_artwork_url }}" />
+      {{ end }}
+  {{ end }}
+  <previously-shown />
+</programme>
diff --git a/ErsatzTV/Services/RunOnce/ResourceExtractorService.cs b/ErsatzTV/Services/RunOnce/ResourceExtractorService.cs
index a61d92ad4..029dfacd9 100644
--- a/ErsatzTV/Services/RunOnce/ResourceExtractorService.cs
+++ b/ErsatzTV/Services/RunOnce/ResourceExtractorService.cs
@@ -67,6 +67,18 @@ public class ResourceExtractorService : BackgroundService
             FileSystemLayout.ChannelGuideTemplatesFolder,
             stoppingToken);
 
+        await ExtractTemplateResource(
+            assembly,
+            "_song.sbntxt",
+            FileSystemLayout.ChannelGuideTemplatesFolder,
+            stoppingToken);
+
+        await ExtractTemplateResource(
+            assembly,
+            "_otherVideo.sbntxt",
+            FileSystemLayout.ChannelGuideTemplatesFolder,
+            stoppingToken);
+
         await ExtractScriptResource(
             assembly,
             "_threePartEpisodes.js",