feat(api): REST endpoints for deco templates and deco template groups (#144 S4 (#162))

Adds DecoTemplateController mirroring TemplateController: CRUD for deco
template groups, deco templates (flat list + by-id), item listing, and a
full-replace PUT for a deco template's item list.

Hardening (deviation from a literal port of the existing handlers, matching
the #144 S2 fix for ReplaceTemplateItemsHandler):
- CreateDecoTemplateHandler now validates DecoTemplateGroupId exists before
  insert (previously a bad id hit the FK constraint at SaveChanges and
  surfaced as a 500; now a 422).
- ReplaceDecoTemplateItemsHandler now rejects invalid items (unknown DecoId,
  StartTime >= EndTime unless EndTime is the end-of-day sentinel 00:00:00,
  or overlapping ranges) with a 422 instead of silently dropping/persisting
  them - the same silent-drop/silent-overlap bug class already fixed for
  templates.

Response DTOs serialize the raw item TimeSpans (via .TimeOfDay), so an
end-of-day item still round-trips as StartTime=22:00:00/EndTime=00:00:00
regardless of the ViewModel's day-wrapping DateTime representation.

ErsatzTV.Application/Scheduling/Commands/CreateDecoTemplateHandler.cs

@@ -27,12 +27,30 @@ public class CreateDecoTemplateHandler(IDbContextFactory<TvContext> dbContextFac
 
     private static async Task<Validation<BaseError, DecoTemplate>> Validate(
         TvContext dbContext,
-        CreateDecoTemplate request) =>
+        CreateDecoTemplate request)
-        await ValidateDecoTemplateName(dbContext, request).MapT(name => new DecoTemplate
+    {
+        Validation<BaseError, Unit> decoTemplateGroupValidation =
+            await ValidateDecoTemplateGroupExists(dbContext, request);
+        Validation<BaseError, string> nameValidation = await ValidateDecoTemplateName(dbContext, request);
+
+        return (decoTemplateGroupValidation, nameValidation).Apply((_, name) => new DecoTemplate
         {
             DecoTemplateGroupId = request.DecoTemplateGroupId,
             Name = name
         });
+    }
+
+    private static async Task<Validation<BaseError, Unit>> ValidateDecoTemplateGroupExists(
+        TvContext dbContext,
+        CreateDecoTemplate request)
+    {
+        bool decoTemplateGroupExists =
+            await dbContext.DecoTemplateGroups.AnyAsync(dtg => dtg.Id == request.DecoTemplateGroupId);
+
+        return decoTemplateGroupExists
+            ? Success<BaseError, Unit>(Unit.Default)
+            : BaseError.New("Deco template group does not exist");
+    }
 
     private static async Task<Validation<BaseError, string>> ValidateDecoTemplateName(
         TvContext dbContext,

ErsatzTV.Application/Scheduling/Commands/ReplaceDecoTemplateItemsHandler.cs

@@ -29,11 +29,7 @@ public class ReplaceDecoTemplateItemsHandler(IDbContextFactory<TvContext> dbCont
 
         dbContext.RemoveRange(decoTemplate.Items);
 
-        // drop items that are invalid
+        decoTemplate.Items = request.Items.Map(i => BuildItem(decoTemplate, i)).ToList();
-        decoTemplate.Items = request.Items
-            .Map(i => BuildItem(decoTemplate, i))
-            .Filter(i => i.StartTime < i.EndTime || i.EndTime == TimeSpan.Zero)
-            .ToList();
 
         await dbContext.SaveChangesAsync(cancellationToken);
 
@@ -66,7 +62,71 @@ public class ReplaceDecoTemplateItemsHandler(IDbContextFactory<TvContext> dbCont
         ReplaceDecoTemplateItems request,
         CancellationToken cancellationToken) =>
         DecoTemplateMustExist(dbContext, request.DecoTemplateId, cancellationToken)
-            .BindT(decoTemplate => DecoTemplateNameMustBeValid(dbContext, decoTemplate, request));
+            .BindT(decoTemplate => DecoTemplateNameMustBeValid(dbContext, decoTemplate, request))
+            .BindT(decoTemplate => DecoTemplateItemsMustBeValid(dbContext, decoTemplate, request));
+
+    // Hardening (deliberate deviation from the original handler): rather than silently filtering out
+    // invalid items (unknown DecoId, StartTime >= EndTime, or overlapping ranges) - the same silent-drop
+    // and silent-overlap bug class fixed for ReplaceTemplateItemsHandler in #144 S2 - reject the whole
+    // request with a 422 so the caller knows exactly what is wrong. EndTime == TimeSpan.Zero means
+    // "end of day" (24:00) and is treated as such for both the ordering and overlap checks.
+    private static async Task<Validation<BaseError, DecoTemplate>> DecoTemplateItemsMustBeValid(
+        TvContext dbContext,
+        DecoTemplate decoTemplate,
+        ReplaceDecoTemplateItems request)
+    {
+        var allDecoIds = request.Items.Map(i => i.DecoId).Distinct().ToList();
+
+        Dictionary<int, Deco> allDecos = await dbContext.Decos
+            .AsNoTracking()
+            .Filter(d => allDecoIds.Contains(d.Id))
+            .ToListAsync()
+            .Map(list => list.ToDictionary(d => d.Id, d => d));
+
+        var missingDecoIds = allDecoIds.Filter(id => !allDecos.ContainsKey(id)).ToList();
+        if (missingDecoIds.Count > 0)
+        {
+            return BaseError.New($"[DecoId] {missingDecoIds.Head()} does not exist.");
+        }
+
+        var itemsWithEffectiveEnd = request.Items
+            .Map(i => new DecoTemplateItemRange(
+                i.DecoId,
+                i.StartTime,
+                i.EndTime,
+                i.EndTime == TimeSpan.Zero ? TimeSpan.FromHours(24) : i.EndTime))
+            .ToList();
+
+        foreach (DecoTemplateItemRange item in itemsWithEffectiveEnd)
+        {
+            if (item.StartTime >= item.EffectiveEndTime)
+            {
+                return BaseError.New(
+                    $"Deco from {item.StartTime} to {item.EndTime} must start before it ends");
+            }
+        }
+
+        foreach (DecoTemplateItemRange item in itemsWithEffectiveEnd)
+        {
+            foreach (DecoTemplateItemRange otherItem in itemsWithEffectiveEnd)
+            {
+                if (item == otherItem)
+                {
+                    continue;
+                }
+
+                if (item.StartTime < otherItem.EffectiveEndTime && otherItem.StartTime < item.EffectiveEndTime)
+                {
+                    return BaseError.New(
+                        $"Deco from {item.StartTime} to {item.EndTime} intersects deco from {otherItem.StartTime} to {otherItem.EndTime}");
+                }
+            }
+        }
+
+        return decoTemplate;
+    }
+
+    private sealed record DecoTemplateItemRange(int DecoId, TimeSpan StartTime, TimeSpan EndTime, TimeSpan EffectiveEndTime);
 
     private static Task<Validation<BaseError, DecoTemplate>> DecoTemplateMustExist(
         TvContext dbContext,

ErsatzTV.Core/Api/Scheduling/DecoTemplateGroupResponseModel.cs

@@ -0,0 +1,4 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record DecoTemplateGroupResponseModel(int Id, string Name, int DecoTemplateCount);

ErsatzTV.Core/Api/Scheduling/DecoTemplateItemResponseModel.cs

@@ -0,0 +1,4 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record DecoTemplateItemResponseModel(int DecoId, string DecoName, TimeSpan StartTime, TimeSpan EndTime);

ErsatzTV.Core/Api/Scheduling/DecoTemplateResponseModel.cs

@@ -0,0 +1,4 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record DecoTemplateResponseModel(int Id, int DecoTemplateGroupId, string GroupName, string Name);

ErsatzTV.Core/Api/Scheduling/DecoTemplateWithItemsResponseModel.cs

@@ -0,0 +1,9 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Scheduling;
+
+public record DecoTemplateWithItemsResponseModel(
+    int Id,
+    int DecoTemplateGroupId,
+    string GroupName,
+    string Name,
+    List<DecoTemplateItemResponseModel> Items);

ErsatzTV.Tests/Controllers/ApiControllerSecurityTests.cs

@@ -29,6 +29,7 @@ public class ApiControllerSecurityTests
             typeof(ChannelController),
             typeof(CollectionController),
             typeof(DecoController),
+            typeof(DecoTemplateController),
             typeof(FFmpegProfileController),
             typeof(FillerPresetController),
             typeof(LibrariesController),

ErsatzTV.Tests/Controllers/ApiErrorResponseMetadataTests.cs

@@ -102,6 +102,16 @@ public class ApiErrorResponseMetadataTests
     [TestCase(typeof(DecoController), nameof(DecoController.Delete), StatusCodes.Status404NotFound)]
     [TestCase(typeof(DecoController), nameof(DecoController.Replace), StatusCodes.Status404NotFound)]
     [TestCase(typeof(DecoController), nameof(DecoController.Replace), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.GetById), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.CreateGroup), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.CreateGroup), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.DeleteGroup), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.Create), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.Create), StatusCodes.Status422UnprocessableEntity)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.Delete), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.GetItems), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.Replace), StatusCodes.Status404NotFound)]
+    [TestCase(typeof(DecoTemplateController), nameof(DecoTemplateController.Replace), StatusCodes.Status422UnprocessableEntity)]
     [TestCase(typeof(PlayoutController), nameof(PlayoutController.UpdateDefaultDeco), StatusCodes.Status404NotFound)]
     [TestCase(typeof(PlayoutController), nameof(PlayoutController.UpdateDefaultDeco), StatusCodes.Status422UnprocessableEntity)]
     [TestCase(typeof(PlayoutController), nameof(PlayoutController.GetById), StatusCodes.Status404NotFound)]

ErsatzTV.Tests/Controllers/DecoTemplateControllerTests.cs

@@ -0,0 +1,348 @@
+using System.Reflection;
+using ErsatzTV.Application.Scheduling;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Controllers.Api.Requests;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Scheduling;
+using LanguageExt;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class DecoTemplateControllerTests
+{
+    private DecoTemplateController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new DecoTemplateController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Routes()
+    {
+        ShouldHaveActionRoute(nameof(DecoTemplateController.GetGroups), "GET", "/api/deco-templates/groups");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.CreateGroup), "POST", "/api/deco-templates/groups");
+        ShouldHaveActionRoute(
+            nameof(DecoTemplateController.DeleteGroup),
+            "DELETE",
+            "/api/deco-templates/groups/{id:int}");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.GetAll), "GET", "/api/deco-templates");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.GetById), "GET", "/api/deco-templates/{id:int}");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.Create), "POST", "/api/deco-templates");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.Delete), "DELETE", "/api/deco-templates/{id:int}");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.GetItems), "GET", "/api/deco-templates/{id:int}/items");
+        ShouldHaveActionRoute(nameof(DecoTemplateController.Replace), "PUT", "/api/deco-templates/{id:int}");
+    }
+
+    [Test]
+    public async Task CreateGroup_Should_Return_201_With_Location_And_Body()
+    {
+        _mediator.Send(Arg.Any<CreateDecoTemplateGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, DecoTemplateGroupViewModel>(new DecoTemplateGroupViewModel(5, "Weekday", 0)));
+
+        IActionResult result = await _controller.CreateGroup(
+            new CreateDecoTemplateGroupRequest("Weekday"),
+            CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/api/deco-templates/groups/5");
+        created.Value.ShouldBeOfType<DecoTemplateGroupResponseModel>().Name.ShouldBe("Weekday");
+        await _mediator.Received(1).Send(
+            Arg.Is<CreateDecoTemplateGroup>(c => c.Name == "Weekday"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task CreateGroup_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<CreateDecoTemplateGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, DecoTemplateGroupViewModel>(BaseError.New("bad")));
+
+        IActionResult result = await _controller.CreateGroup(
+            new CreateDecoTemplateGroupRequest(string.Empty),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+    }
+
+    [Test]
+    public async Task DeleteGroup_Should_Return_204_When_Exists()
+    {
+        _mediator.Send(Arg.Any<GetAllDecoTemplateGroups>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateGroupViewModel> { new(3, "Weekday", 0) });
+        _mediator.Send(Arg.Any<DeleteDecoTemplateGroup>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BaseError>.None);
+
+        IActionResult result = await _controller.DeleteGroup(3, CancellationToken.None);
+
+        result.ShouldBeOfType<NoContentResult>();
+        await _mediator.Received(1).Send(
+            Arg.Is<DeleteDecoTemplateGroup>(c => c.DecoTemplateGroupId == 3),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task DeleteGroup_Should_Return_404_When_Missing()
+    {
+        _mediator.Send(Arg.Any<GetAllDecoTemplateGroups>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateGroupViewModel>());
+
+        IActionResult result = await _controller.DeleteGroup(99, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<DeleteDecoTemplateGroup>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetAll_Should_Flatten_DecoTemplates_Across_Groups()
+    {
+        _mediator.Send(Arg.Any<GetAllDecoTemplateGroups>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateGroupViewModel> { new(2, "Weekday", 1) });
+        _mediator.Send(Arg.Any<GetDecoTemplatesByDecoTemplateGroupId>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateViewModel> { MakeDecoTemplate(1, 2, "Morning") });
+
+        List<DecoTemplateResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.Count.ShouldBe(1);
+        result[0].Id.ShouldBe(1);
+        result[0].DecoTemplateGroupId.ShouldBe(2);
+        result[0].Name.ShouldBe("Morning");
+        await _mediator.Received(1).Send(
+            Arg.Is<GetDecoTemplatesByDecoTemplateGroupId>(c => c.DecoTemplateGroupId == 2),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetById_Should_Return_200_For_Some()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 2, "Morning")));
+
+        IActionResult result = await _controller.GetById(4, CancellationToken.None);
+
+        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<DecoTemplateResponseModel>().Id.ShouldBe(4);
+    }
+
+    [Test]
+    public async Task GetById_Should_Return_404_For_None()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.None);
+
+        IActionResult result = await _controller.GetById(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
+    [Test]
+    public async Task Create_Should_Return_201_And_Map_Request()
+    {
+        _mediator.Send(Arg.Any<CreateDecoTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, DecoTemplateViewModel>(MakeDecoTemplate(8, 2, "Morning")));
+
+        IActionResult result = await _controller.Create(
+            new CreateDecoTemplateRequest(2, "Morning"),
+            CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/api/deco-templates/8");
+        await _mediator.Received(1).Send(
+            Arg.Is<CreateDecoTemplate>(c => c.DecoTemplateGroupId == 2 && c.Name == "Morning"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Create_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<CreateDecoTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, DecoTemplateViewModel>(BaseError.New("dupe")));
+
+        IActionResult result = await _controller.Create(
+            new CreateDecoTemplateRequest(2, "Morning"),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+    }
+
+    [Test]
+    public async Task Delete_Should_Return_204_When_Exists()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<DeleteDecoTemplate>(), Arg.Any<CancellationToken>())
+            .Returns(Option<BaseError>.None);
+
+        IActionResult result = await _controller.Delete(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NoContentResult>();
+    }
+
+    [Test]
+    public async Task Delete_Should_Return_404_When_Missing()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.None);
+
+        IActionResult result = await _controller.Delete(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<DeleteDecoTemplate>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetItems_Should_Return_200_Ordered_By_StartTime()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<GetDecoTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateItemViewModel>
+            {
+                MakeItem(20, "News Bumper", TimeSpan.FromHours(12), TimeSpan.FromHours(13)),
+                MakeItem(10, "Morning Bumper", TimeSpan.FromHours(6), TimeSpan.FromHours(7))
+            });
+
+        IActionResult result = await _controller.GetItems(4, CancellationToken.None);
+
+        var items = result.ShouldBeOfType<OkObjectResult>().Value
+            .ShouldBeOfType<List<DecoTemplateItemResponseModel>>();
+        items.Count.ShouldBe(2);
+        items[0].DecoId.ShouldBe(10);
+        items[0].StartTime.ShouldBe(TimeSpan.FromHours(6));
+        items[0].EndTime.ShouldBe(TimeSpan.FromHours(7));
+        items[1].DecoId.ShouldBe(20);
+    }
+
+    [Test]
+    public async Task GetItems_Should_Return_End_Of_Day_As_Midnight()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 2, "Morning")));
+        _mediator.Send(Arg.Any<GetDecoTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateItemViewModel>
+            {
+                MakeItem(10, "Overnight Bumper", TimeSpan.FromHours(22), TimeSpan.Zero)
+            });
+
+        IActionResult result = await _controller.GetItems(4, CancellationToken.None);
+
+        var items = result.ShouldBeOfType<OkObjectResult>().Value
+            .ShouldBeOfType<List<DecoTemplateItemResponseModel>>();
+        items[0].StartTime.ShouldBe(TimeSpan.FromHours(22));
+        items[0].EndTime.ShouldBe(TimeSpan.Zero);
+    }
+
+    [Test]
+    public async Task GetItems_Should_Return_404_When_DecoTemplate_Missing()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.None);
+
+        IActionResult result = await _controller.GetItems(4, CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+    }
+
+    [Test]
+    public async Task Replace_Should_Return_200_With_Refreshed_DecoTemplate_And_Map_Items()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 7, "Morning")));
+        _mediator.Send(Arg.Any<ReplaceDecoTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, List<DecoTemplateItemViewModel>>([]));
+        _mediator.Send(Arg.Any<GetDecoTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(new List<DecoTemplateItemViewModel>
+            {
+                MakeItem(10, "Morning Bumper", TimeSpan.FromHours(6), TimeSpan.FromHours(7))
+            });
+
+        IActionResult result = await _controller.Replace(
+            4,
+            new ReplaceDecoTemplateRequest(
+                "Morning",
+                [new DecoTemplateItemRequest(10, TimeSpan.FromHours(6), TimeSpan.FromHours(7))]),
+            CancellationToken.None);
+
+        var body = result.ShouldBeOfType<OkObjectResult>().Value
+            .ShouldBeOfType<DecoTemplateWithItemsResponseModel>();
+        body.Id.ShouldBe(4);
+        body.Items.Count.ShouldBe(1);
+        await _mediator.Received(1).Send(
+            Arg.Is<ReplaceDecoTemplateItems>(c =>
+                c.DecoTemplateId == 4 &&
+                c.DecoTemplateGroupId == 7 &&
+                c.Name == "Morning" &&
+                c.Items.Count == 1 &&
+                c.Items[0].DecoId == 10 &&
+                c.Items[0].StartTime == TimeSpan.FromHours(6) &&
+                c.Items[0].EndTime == TimeSpan.FromHours(7)),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Replace_Should_Return_404_When_DecoTemplate_Missing()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.None);
+
+        IActionResult result = await _controller.Replace(
+            4,
+            new ReplaceDecoTemplateRequest("Morning", []),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<NotFoundObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<ReplaceDecoTemplateItems>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Replace_Should_Return_422_On_Validation_Error()
+    {
+        _mediator.Send(Arg.Any<GetDecoTemplateById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<DecoTemplateViewModel>.Some(MakeDecoTemplate(4, 7, "Morning")));
+        _mediator.Send(Arg.Any<ReplaceDecoTemplateItems>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, List<DecoTemplateItemViewModel>>(BaseError.New("overlap")));
+
+        IActionResult result = await _controller.Replace(
+            4,
+            new ReplaceDecoTemplateRequest("Morning", []),
+            CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<GetDecoTemplateItems>(), Arg.Any<CancellationToken>());
+    }
+
+    private static DecoTemplateViewModel MakeDecoTemplate(int id, int groupId, string name) =>
+        new(id, groupId, "Group", name);
+
+    private static DecoTemplateItemViewModel MakeItem(int decoId, string decoName, TimeSpan startTime, TimeSpan endTime)
+    {
+        DateTime start = DateTime.Today.Add(startTime);
+        DateTime end = DateTime.Today.Add(endTime);
+        if (start > end)
+        {
+            end = end.AddDays(1);
+        }
+
+        return new DecoTemplateItemViewModel(decoId, decoName, start, end);
+    }
+
+    private static void ShouldHaveActionRoute(string actionName, string httpMethod, string route)
+    {
+        MethodInfo action = typeof(DecoTemplateController).GetMethod(actionName)
+            ?? throw new AssertionException($"Missing action {actionName}");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain(httpMethod);
+        attribute.Template.ShouldBe(route);
+    }
+}

ErsatzTV/Controllers/Api/DecoTemplateController.cs

@@ -0,0 +1,221 @@
+using System.ComponentModel.DataAnnotations;
+using ErsatzTV.Application.Scheduling;
+using ErsatzTV.Controllers.Api.Requests;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Scheduling;
+using ErsatzTV.Extensions;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class DecoTemplateController(IMediator mediator) : ControllerBase
+{
+    [HttpGet("/api/deco-templates/groups", Name = "GetDecoTemplateGroups")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Get all deco template groups")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<DecoTemplateGroupResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<DecoTemplateGroupResponseModel>> GetGroups(CancellationToken cancellationToken)
+    {
+        List<DecoTemplateGroupViewModel> groups =
+            await mediator.Send(new GetAllDecoTemplateGroups(), cancellationToken);
+        return groups.Map(ProjectToResponseModel).ToList();
+    }
+
+    [HttpPost("/api/deco-templates/groups")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Create a deco template group")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(DecoTemplateGroupResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> CreateGroup(
+        [Required] [FromBody] CreateDecoTemplateGroupRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, DecoTemplateGroupViewModel> result =
+            await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.ToCreatedResult(
+            vm => $"/api/deco-templates/groups/{vm.Id}",
+            vm => ProjectToResponseModel(vm));
+    }
+
+    [HttpDelete("/api/deco-templates/groups/{id:int}")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Delete a deco template group")]
+    [EndpointDescription(
+        "Deletes the deco template group. The database cascade removes every deco template (and its items) in " +
+        "the group; any playout template that used a removed deco template has that reference cleared.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> DeleteGroup(int id, CancellationToken cancellationToken)
+    {
+        List<DecoTemplateGroupViewModel> groups =
+            await mediator.Send(new GetAllDecoTemplateGroups(), cancellationToken);
+        if (groups.All(g => g.Id != id))
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        Option<BaseError> result = await mediator.Send(new DeleteDecoTemplateGroup(id), cancellationToken);
+        return result.Match<IActionResult>(
+            Some: error => error.ToErrorResult(),
+            None: () => new NoContentResult());
+    }
+
+    [HttpGet("/api/deco-templates")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Get all deco templates")]
+    [EndpointDescription(
+        "Returns every deco template as a flat list, ordered by group name then deco template name.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<DecoTemplateResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<DecoTemplateResponseModel>> GetAll(CancellationToken cancellationToken)
+    {
+        List<DecoTemplateGroupViewModel> groups =
+            await mediator.Send(new GetAllDecoTemplateGroups(), cancellationToken);
+        var result = new List<DecoTemplateResponseModel>();
+        foreach (DecoTemplateGroupViewModel group in groups)
+        {
+            List<DecoTemplateViewModel> decoTemplates =
+                await mediator.Send(new GetDecoTemplatesByDecoTemplateGroupId(group.Id), cancellationToken);
+            result.AddRange(decoTemplates.Map(ProjectToResponseModel));
+        }
+
+        return result;
+    }
+
+    [HttpGet("/api/deco-templates/{id:int}", Name = "GetDecoTemplateById")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Get a deco template by id")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(DecoTemplateResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetById(int id, CancellationToken cancellationToken)
+    {
+        Option<DecoTemplateViewModel> result = await mediator.Send(new GetDecoTemplateById(id), cancellationToken);
+        return result.Map(ProjectToResponseModel).ToGetResult();
+    }
+
+    [HttpPost("/api/deco-templates")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Create a deco template")]
+    [EndpointDescription("Creates an empty deco template in the given deco template group.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(DecoTemplateResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Create(
+        [Required] [FromBody] CreateDecoTemplateRequest request,
+        CancellationToken cancellationToken)
+    {
+        Either<BaseError, DecoTemplateViewModel> result =
+            await mediator.Send(request.ToCommand(), cancellationToken);
+        return result.ToCreatedResult(
+            vm => $"/api/deco-templates/{vm.Id}",
+            vm => ProjectToResponseModel(vm));
+    }
+
+    [HttpDelete("/api/deco-templates/{id:int}")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Delete a deco template")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Delete(int id, CancellationToken cancellationToken)
+    {
+        Option<DecoTemplateViewModel> existing = await mediator.Send(new GetDecoTemplateById(id), cancellationToken);
+        if (existing.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        Option<BaseError> result = await mediator.Send(new DeleteDecoTemplate(id), cancellationToken);
+        return result.Match<IActionResult>(
+            Some: error => error.ToErrorResult(),
+            None: () => new NoContentResult());
+    }
+
+    [HttpGet("/api/deco-templates/{id:int}/items")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Get deco template items")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<DecoTemplateItemResponseModel>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetItems(int id, CancellationToken cancellationToken)
+    {
+        Option<DecoTemplateViewModel> decoTemplate = await mediator.Send(new GetDecoTemplateById(id), cancellationToken);
+        if (decoTemplate.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        List<DecoTemplateItemViewModel> items = await mediator.Send(new GetDecoTemplateItems(id), cancellationToken);
+        return new OkObjectResult(
+            items.OrderBy(i => i.StartTime.TimeOfDay).Map(ProjectToResponseModel).ToList());
+    }
+
+    [HttpPut("/api/deco-templates/{id:int}")]
+    [Tags("DecoTemplates")]
+    [EndpointSummary("Replace a deco template and its items")]
+    [EndpointDescription(
+        "Replaces the deco template's name and its full item list. Each item assigns a deco to a start/end time " +
+        "of day; an end time of 00:00:00 means the item runs to the end of the day. Items must not overlap.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(DecoTemplateWithItemsResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Replace(
+        int id,
+        [Required] [FromBody] ReplaceDecoTemplateRequest request,
+        CancellationToken cancellationToken)
+    {
+        Option<DecoTemplateViewModel> maybeDecoTemplate =
+            await mediator.Send(new GetDecoTemplateById(id), cancellationToken);
+        if (maybeDecoTemplate.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        int decoTemplateGroupId = maybeDecoTemplate.Map(t => t.DecoTemplateGroupId).IfNone(0);
+
+        Either<BaseError, List<DecoTemplateItemViewModel>> result =
+            await mediator.Send(request.ToCommand(decoTemplateGroupId, id), cancellationToken);
+
+        return await result.Match(
+            Left: error => Task.FromResult(error.ToErrorResult()),
+            Right: async _ =>
+            {
+                Option<DecoTemplateViewModel> refreshed =
+                    await mediator.Send(new GetDecoTemplateById(id), cancellationToken);
+                List<DecoTemplateItemViewModel> items =
+                    await mediator.Send(new GetDecoTemplateItems(id), cancellationToken);
+                return refreshed.Match(
+                    Some: vm => (IActionResult)new OkObjectResult(ProjectToWithItemsResponseModel(vm, items)),
+                    None: () => ApiResults.NotFoundProblem());
+            });
+    }
+
+    private static DecoTemplateGroupResponseModel ProjectToResponseModel(DecoTemplateGroupViewModel vm) =>
+        new(vm.Id, vm.Name, vm.DecoTemplateCount);
+
+    private static DecoTemplateResponseModel ProjectToResponseModel(DecoTemplateViewModel vm) =>
+        new(vm.Id, vm.DecoTemplateGroupId, vm.GroupName, vm.Name);
+
+    private static DecoTemplateWithItemsResponseModel ProjectToWithItemsResponseModel(
+        DecoTemplateViewModel vm,
+        List<DecoTemplateItemViewModel> items) =>
+        new(
+            vm.Id,
+            vm.DecoTemplateGroupId,
+            vm.GroupName,
+            vm.Name,
+            items.OrderBy(i => i.StartTime.TimeOfDay).Map(ProjectToResponseModel).ToList());
+
+    private static DecoTemplateItemResponseModel ProjectToResponseModel(DecoTemplateItemViewModel vm) =>
+        new(vm.DecoId, vm.DecoName, vm.StartTime.TimeOfDay, vm.EndTime.TimeOfDay);
+}

ErsatzTV/Controllers/Api/Requests/CreateDecoTemplateGroupRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record CreateDecoTemplateGroupRequest(string Name)
+{
+    public CreateDecoTemplateGroup ToCommand() => new(Name);
+}

ErsatzTV/Controllers/Api/Requests/CreateDecoTemplateRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record CreateDecoTemplateRequest(int DecoTemplateGroupId, string Name)
+{
+    public CreateDecoTemplate ToCommand() => new(DecoTemplateGroupId, Name);
+}

ErsatzTV/Controllers/Api/Requests/DecoTemplateItemRequest.cs

@@ -0,0 +1,8 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record DecoTemplateItemRequest(int DecoId, TimeSpan StartTime, TimeSpan EndTime)
+{
+    public ReplaceDecoTemplateItem ToReplaceItem() => new(DecoId, StartTime, EndTime);
+}

ErsatzTV/Controllers/Api/Requests/ReplaceDecoTemplateRequest.cs

@@ -0,0 +1,13 @@
+using ErsatzTV.Application.Scheduling;
+
+namespace ErsatzTV.Controllers.Api.Requests;
+
+public record ReplaceDecoTemplateRequest(string Name, List<DecoTemplateItemRequest> Items)
+{
+    public ReplaceDecoTemplateItems ToCommand(int decoTemplateGroupId, int decoTemplateId) =>
+        new(
+            decoTemplateId,
+            decoTemplateGroupId,
+            Name,
+            (Items ?? []).Select(item => item.ToReplaceItem()).ToList());
+}

ErsatzTV/wwwroot/openapi/v1.json

@@ -3247,6 +3247,597 @@
         }
       }
     },
+    "/api/deco-templates/groups": {
+      "get": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Get all deco template groups",
+        "operationId": "GetDecoTemplateGroups",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                  }
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                  }
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Create a deco template group",
+        "requestBody": {
+          "content": {
+            "application/json-patch+json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateGroupRequest"
+              }
+            },
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateGroupRequest"
+              }
+            },
+            "text/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateGroupRequest"
+              }
+            },
+            "application/*+json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateGroupRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "201": {
+            "description": "Created",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateGroupResponseModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Unprocessable Entity",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/deco-templates/groups/{id}": {
+      "delete": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Delete a deco template group",
+        "description": "Deletes the deco template group. The database cascade removes every deco template (and its items) in the group; any playout template that used a removed deco template has that reference cleared.",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/deco-templates": {
+      "get": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Get all deco templates",
+        "description": "Returns every deco template as a flat list, ordered by group name then deco template name.",
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                  }
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                  }
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Create a deco template",
+        "description": "Creates an empty deco template in the given deco template group.",
+        "requestBody": {
+          "content": {
+            "application/json-patch+json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateRequest"
+              }
+            },
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateRequest"
+              }
+            },
+            "text/json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateRequest"
+              }
+            },
+            "application/*+json": {
+              "schema": {
+                "$ref": "#/components/schemas/CreateDecoTemplateRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "201": {
+            "description": "Created",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Unprocessable Entity",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/deco-templates/{id}": {
+      "get": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Get a deco template by id",
+        "operationId": "GetDecoTemplateById",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateResponseModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      },
+      "delete": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Delete a deco template",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "No Content"
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      },
+      "put": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Replace a deco template and its items",
+        "description": "Replaces the deco template's name and its full item list. Each item assigns a deco to a start/end time of day; an end time of 00:00:00 means the item runs to the end of the day. Items must not overlap.",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json-patch+json": {
+              "schema": {
+                "$ref": "#/components/schemas/ReplaceDecoTemplateRequest"
+              }
+            },
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ReplaceDecoTemplateRequest"
+              }
+            },
+            "text/json": {
+              "schema": {
+                "$ref": "#/components/schemas/ReplaceDecoTemplateRequest"
+              }
+            },
+            "application/*+json": {
+              "schema": {
+                "$ref": "#/components/schemas/ReplaceDecoTemplateRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateWithItemsResponseModel"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateWithItemsResponseModel"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/DecoTemplateWithItemsResponseModel"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Unprocessable Entity",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "/api/deco-templates/{id}/items": {
+      "get": {
+        "tags": [
+          "DecoTemplates"
+        ],
+        "summary": "Get deco template items",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "integer",
+              "format": "int32"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateItemResponseModel"
+                  }
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateItemResponseModel"
+                  }
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/DecoTemplateItemResponseModel"
+                  }
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "text/plain": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              },
+              "text/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
     "/api/ffmpeg/profiles": {
       "get": {
         "tags": [
@@ -11876,6 +12467,39 @@
           }
         }
       },
+      "CreateDecoTemplateGroupRequest": {
+        "required": [
+          "name"
+        ],
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": [
+              "null",
+              "string"
+            ]
+          }
+        }
+      },
+      "CreateDecoTemplateRequest": {
+        "required": [
+          "decoTemplateGroupId",
+          "name"
+        ],
+        "type": "object",
+        "properties": {
+          "decoTemplateGroupId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "name": {
+            "type": [
+              "null",
+              "string"
+            ]
+          }
+        }
+      },
       "CreateFFmpegProfileRequest": {
         "required": [
           "name",
@@ -12724,6 +13348,132 @@
           }
         }
       },
+      "DecoTemplateGroupResponseModel": {
+        "required": [
+          "id",
+          "name",
+          "decoTemplateCount"
+        ],
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "name": {
+            "type": "string"
+          },
+          "decoTemplateCount": {
+            "type": "integer",
+            "format": "int32"
+          }
+        }
+      },
+      "DecoTemplateItemRequest": {
+        "required": [
+          "decoId",
+          "startTime",
+          "endTime"
+        ],
+        "type": "object",
+        "properties": {
+          "decoId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "startTime": {
+            "pattern": "^-?(\\d+\\.)?\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,7})?$",
+            "type": "string"
+          },
+          "endTime": {
+            "pattern": "^-?(\\d+\\.)?\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,7})?$",
+            "type": "string"
+          }
+        }
+      },
+      "DecoTemplateItemResponseModel": {
+        "required": [
+          "decoId",
+          "decoName",
+          "startTime",
+          "endTime"
+        ],
+        "type": "object",
+        "properties": {
+          "decoId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "decoName": {
+            "type": "string"
+          },
+          "startTime": {
+            "pattern": "^-?(\\d+\\.)?\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,7})?$",
+            "type": "string"
+          },
+          "endTime": {
+            "pattern": "^-?(\\d+\\.)?\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,7})?$",
+            "type": "string"
+          }
+        }
+      },
+      "DecoTemplateResponseModel": {
+        "required": [
+          "id",
+          "decoTemplateGroupId",
+          "groupName",
+          "name"
+        ],
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "decoTemplateGroupId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "groupName": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          }
+        }
+      },
+      "DecoTemplateWithItemsResponseModel": {
+        "required": [
+          "id",
+          "decoTemplateGroupId",
+          "groupName",
+          "name",
+          "items"
+        ],
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "decoTemplateGroupId": {
+            "type": "integer",
+            "format": "int32"
+          },
+          "groupName": {
+            "type": "string"
+          },
+          "name": {
+            "type": "string"
+          },
+          "items": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/DecoTemplateItemResponseModel"
+            }
+          }
+        }
+      },
       "DeleteMediaItemsRequest": {
         "required": [
           "ids"
@@ -14815,6 +15565,30 @@
           }
         }
       },
+      "ReplaceDecoTemplateRequest": {
+        "required": [
+          "name",
+          "items"
+        ],
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": [
+              "null",
+              "string"
+            ]
+          },
+          "items": {
+            "type": [
+              "null",
+              "array"
+            ],
+            "items": {
+              "$ref": "#/components/schemas/DecoTemplateItemRequest"
+            }
+          }
+        }
+      },
       "ReplaceScheduleItemsRequest": {
         "required": [
           "items"
@@ -16927,6 +17701,9 @@
     {
       "name": "Decos"
     },
+    {
+      "name": "DecoTemplates"
+    },
     {
       "name": "FFmpeg Profiles"
     },