From 47f3a703bf06e17309e00a3696105e43775a81ed Mon Sep 17 00:00:00 2001
From: Joseph Doherty <dohejw01@gmail.com>
Date: Mon, 9 Nov 2026 15:42:56 -0500
Subject: [PATCH] perf(search): prefix-by-default Deployments and config-audit
 search; bounded Contains opt-in (ScadaBridge#50)

Deployments free-text search and the config-audit EntityName filter no longer
emit LIKE '%term%' by default. Prefix (LIKE 'term%') is the default; substring
is an explicit opt-in (DeploymentSearchMode.Contains / entityNameContains)
always bounded by a DeployedAt/Timestamp window (explicit, else 30 days).
Migration PrefixSearchIndexes adds DeployedBy, RevisionHash and EntityName
indexes. Deployments page gains a 'Match anywhere' checkbox.

Claude-Session: https://claude.ai/code/session_01GT67AEHd2Acv1YPwGfXEoV
---
 CLAUDE.md                                     |    1 +
 docs/plans/sql/PrefixSearchIndexes.sql        |   26 +
 .../Pages/Deployment/Deployments.razor        |   26 +-
 .../Repositories/ICentralUiRepository.cs      |   12 +-
 .../Types/Deployment/DeploymentListFilter.cs  |   41 +-
 .../Configurations/AuditConfiguration.cs      |    2 +
 .../Configurations/DeploymentConfiguration.cs |    5 +
 ...1109203753_PrefixSearchIndexes.Designer.cs | 2184 +++++++++++++++++
 .../20261109203753_PrefixSearchIndexes.cs     |   45 +
 .../ScadaBridgeDbContextModelSnapshot.cs      |    9 +
 .../Repositories/CentralUiRepository.cs       |   76 +-
 .../DeploymentManagerRepository.cs            |   30 +-
 ...W.ScadaBridge.ConfigurationDatabase.csproj |    4 +
 .../DeploymentListQueryRepositoryTests.cs     |    2 +-
 .../SearchPrefixQueryTests.cs                 |  201 ++
 15 files changed, 2620 insertions(+), 44 deletions(-)
 create mode 100644 docs/plans/sql/PrefixSearchIndexes.sql
 create mode 100644 src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/20261109203753_PrefixSearchIndexes.Designer.cs
 create mode 100644 src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/20261109203753_PrefixSearchIndexes.cs
 create mode 100644 tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/SearchPrefixQueryTests.cs

diff --git a/CLAUDE.md b/CLAUDE.md
index 21a8476f..0f345c03 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -229,6 +229,7 @@ spec for each is `docs/requirements/Component-<Name>.md`, and `README.md` carrie
 - Host readiness gating: `/health/ready` endpoint, no traffic until operational.
 - EF Core migrations: auto-apply in dev, manual SQL scripts for production. Gotcha: `dotnet ef migrations add … --no-build` scaffolds off the previously-built DLL and can emit an **empty** migration — build first (drop the `--no-build`), and delete the empty `Migrations/` files if it happens (`migrations remove` needs a live DB).
 - Audit logging absorbed into Configuration Database component (IAuditService). The config `AuditLogEntries` table stores **summaries** (a script body is recorded as length + SHA-256), caps `AfterStateJson` at 256 K chars, pages deterministically on `(Timestamp DESC, Id DESC)`, and has an optional purge: `ScadaBridge:ConfigAudit:RetentionDays` (default `0` = retained indefinitely), `PurgeBatchSize` 5000, `MaxBatchesPerTick` 200, `PurgeInterval` (bound with `ValidateOnStart` on Central).
+- **Search is prefix by default (ScadaBridge#50, register row 36).** The Deployments page search (instance name, deployment id, revision hash, user) and the config-audit `EntityName` filter are `LIKE 'term%'` (index-seekable); a substring match is an explicit opt-in (`DeploymentListFilter.SearchMode = Contains` / the page's "Match anywhere" checkbox; `GetAuditLogEntriesAsync(entityNameContains: true)`) that is ALWAYS bounded to a `DeployedAt`/`Timestamp` window (explicit `DeployedFrom`/`from`, else the last 30 days). Migration `PrefixSearchIndexes` (script `docs/plans/sql/PrefixSearchIndexes.sql`; not applied to QA/prod) adds the `DeployedBy`, `RevisionHash` and `AuditLogEntries.EntityName` indexes. Tests: `SearchPrefixQueryTests` (SQL-shape via `ToQueryString`).
 - **Review remediation 2026-10-21** (8-slice system review, ~107 findings, 4 High; record `docs/plans/2026-10-21-system-review-remediation.md`). Decisions: CLI uses bearer-per-invocation (see Security); the never-read `Database:MachineDataDb` option was **removed** (it was a required boot key); config audit stores summaries + retention (above); a **bound Test Run** (Test Run against a deployed instance) now needs Deployer + site scope and writes an audit row; persisted static overrides **seed** script state at actor start without firing scripts (alarms still evaluate). Also changed: site deploy gate rejects non-actor-safe (`ActorNameRules`) instance/script/alarm/native-source names and Data Connection actor names are ASCII-sanitised with collision rejection; site gRPC addresses are validated on every write path (management + Transport import); artifact applies are serialised per site with a 10-min stuck-apply watchdog; `IDataConnection.WriteBatchAndWaitAsync` is **gone** (the script-level handshake composes `WriteTagBatchRequest` + waiter); `instance list --search` is a **prefix** match paged in SQL; command-plane failback probes readiness with a real RPC (probation 5 min); `Transport:SchemaVersionMajor` removed; migration `ReviewRemediationIndexes` (script `docs/plans/sql/ReviewRemediationIndexes.sql`; **QA/prod not yet applied**). New register rows 128-135; row 117 closed.
 
 ### Akka.NET Conventions
diff --git a/docs/plans/sql/PrefixSearchIndexes.sql b/docs/plans/sql/PrefixSearchIndexes.sql
new file mode 100644
index 00000000..ebd06890
--- /dev/null
+++ b/docs/plans/sql/PrefixSearchIndexes.sql
@@ -0,0 +1,26 @@
+-- PrefixSearchIndexes (2026-11-09, ScadaBridge#50). Indexes backing the prefix search on the
+-- Deployments page (DeployedBy, RevisionHash) and the config-audit EntityName filter.
+BEGIN TRANSACTION;
+ALTER TABLE [TemplateNativeAlarmSources] ADD [IsMesReportable] bit NOT NULL DEFAULT CAST(0 AS bit);
+
+ALTER TABLE [InstanceNativeAlarmSourceOverrides] ADD [IsMesReportableOverride] bit NULL;
+
+INSERT INTO [__EFMigrationsHistory] ([MigrationId], [ProductVersion])
+VALUES (N'20261109200211_AddNativeAlarmSourceMesReportable', N'10.0.13');
+
+COMMIT;
+GO
+
+BEGIN TRANSACTION;
+CREATE INDEX [IX_DeploymentRecords_DeployedBy] ON [DeploymentRecords] ([DeployedBy]);
+
+CREATE INDEX [IX_DeploymentRecords_RevisionHash] ON [DeploymentRecords] ([RevisionHash]);
+
+CREATE INDEX [IX_AuditLogEntries_EntityName] ON [AuditLogEntries] ([EntityName]);
+
+INSERT INTO [__EFMigrationsHistory] ([MigrationId], [ProductVersion])
+VALUES (N'20261109203753_PrefixSearchIndexes', N'10.0.13');
+
+COMMIT;
+GO
+
diff --git a/src/ZB.MOM.WW.ScadaBridge.CentralUI/Components/Pages/Deployment/Deployments.razor b/src/ZB.MOM.WW.ScadaBridge.CentralUI/Components/Pages/Deployment/Deployments.razor
index c2a7a40c..4dca5892 100644
--- a/src/ZB.MOM.WW.ScadaBridge.CentralUI/Components/Pages/Deployment/Deployments.razor
+++ b/src/ZB.MOM.WW.ScadaBridge.CentralUI/Components/Pages/Deployment/Deployments.razor
@@ -75,6 +75,15 @@
                            data-test="deploy-search"
                            value="@_searchInput"
                            @oninput="OnSearchInput" />
+                    <div class="form-check mt-1">
+                        <input id="dep-search-contains" type="checkbox" class="form-check-input"
+                               data-test="deploy-search-contains"
+                               checked="@_searchContains"
+                               @onchange="SetSearchContainsAsync" />
+                        <label class="form-check-label small text-muted" for="dep-search-contains">
+                            Match anywhere in the text (last 30 days only; default matches the start)
+                        </label>
+                    </div>
                 </div>
                 <div class="col-auto">
                     <button class="btn btn-outline-secondary btn-sm" data-test="deploy-clear-filters"
@@ -522,6 +531,19 @@
         }
     }
 
+    /// <summary>
+    /// Opt-in substring search. Scans, so the repository bounds it to the last 30 days
+    /// (ScadaBridge#50); the default is an index-friendly prefix match.
+    /// </summary>
+    private bool _searchContains;
+
+    private async Task SetSearchContainsAsync(ChangeEventArgs e)
+    {
+        _searchContains = e.Value is true;
+        _currentPage = 1;
+        await LoadDataAsync();
+    }
+
     private async Task SetStatusFilterAsync(DeploymentStatus? status)
     {
         // Clicking the active tile clears it — a toggle, so the tiles are both the
@@ -536,6 +558,7 @@
         _statusFilter = null;
         _searchInput = string.Empty;
         _appliedSearch = string.Empty;
+        _searchContains = false;
         _currentPage = 1;
 
         // A cleared box must not be re-queried by an armed keystroke timer.
@@ -587,7 +610,8 @@
             var filter = new DeploymentListFilter(
                 Status: _statusFilter,
                 Search: _appliedSearch,
-                SiteIdScope: siteScope);
+                SiteIdScope: siteScope,
+                SearchMode: _searchContains ? DeploymentSearchMode.Contains : DeploymentSearchMode.Prefix);
 
             var page = await DeploymentManagerRepository
                 .QueryDeploymentListPageAsync(filter, pageToQuery, PageSize);
diff --git a/src/ZB.MOM.WW.ScadaBridge.Commons/Interfaces/Repositories/ICentralUiRepository.cs b/src/ZB.MOM.WW.ScadaBridge.Commons/Interfaces/Repositories/ICentralUiRepository.cs
index 3267b527..7c33cb0d 100644
--- a/src/ZB.MOM.WW.ScadaBridge.Commons/Interfaces/Repositories/ICentralUiRepository.cs
+++ b/src/ZB.MOM.WW.ScadaBridge.Commons/Interfaces/Repositories/ICentralUiRepository.cs
@@ -56,11 +56,18 @@ public interface ICentralUiRepository
     /// <param name="from">Optional start of date range filter.</param>
     /// <param name="to">Optional end of date range filter.</param>
     /// <param name="entityId">Optional entity ID filter.</param>
-    /// <param name="entityName">Optional entity name filter.</param>
+    /// <param name="entityName">
+    /// Optional entity name filter. A case-insensitive PREFIX match by default (index-friendly);
+    /// see <paramref name="entityNameContains"/>.
+    /// </param>
     /// <param name="bundleImportId">Optional bundle import correlation ID filter.</param>
     /// <param name="page">One-based page number.</param>
     /// <param name="pageSize">Number of entries per page.</param>
     /// <param name="cancellationToken">Cancellation token.</param>
+    /// <param name="entityNameContains">
+    /// Opt in to a substring match on <paramref name="entityName"/>. This scans, so it is always
+    /// bounded to a time window: <paramref name="from"/>, or the last 30 days when null.
+    /// </param>
     /// <returns>A task that resolves to a tuple of the matching entries and the total count.</returns>
     Task<(IReadOnlyList<AuditLogEntry> Entries, int TotalCount)> GetAuditLogEntriesAsync(
         string? user = null,
@@ -73,7 +80,8 @@ public interface ICentralUiRepository
         Guid? bundleImportId = null,
         int page = 1,
         int pageSize = 50,
-        CancellationToken cancellationToken = default);
+        CancellationToken cancellationToken = default,
+        bool entityNameContains = false);
 
     /// <summary>Persists pending changes to the underlying store.</summary>
     /// <param name="cancellationToken">Cancellation token.</param>
diff --git a/src/ZB.MOM.WW.ScadaBridge.Commons/Types/Deployment/DeploymentListFilter.cs b/src/ZB.MOM.WW.ScadaBridge.Commons/Types/Deployment/DeploymentListFilter.cs
index ea2cb8ae..51e1503b 100644
--- a/src/ZB.MOM.WW.ScadaBridge.Commons/Types/Deployment/DeploymentListFilter.cs
+++ b/src/ZB.MOM.WW.ScadaBridge.Commons/Types/Deployment/DeploymentListFilter.cs
@@ -21,9 +21,11 @@ namespace ZB.MOM.WW.ScadaBridge.Commons.Types.Deployment;
 /// must keep showing its own total while that same status is the active filter.
 /// </param>
 /// <param name="Search">
-/// Free-text term matched (case-insensitively, as a substring) against the
-/// instance unique name, the deployment id, the revision hash and the initiating
-/// user. Blank/whitespace is treated as unconstrained.
+/// Free-text term matched (case-insensitively) against the instance unique name,
+/// the deployment id, the revision hash and the initiating user. By default
+/// (<see cref="DeploymentSearchMode.Prefix"/>) it is a PREFIX match, which can seek
+/// the column indexes; <see cref="DeploymentSearchMode.Contains"/> opts back into the
+/// substring match, bounded to a time window. Blank/whitespace is unconstrained.
 /// </param>
 /// <param name="SiteIdScope">
 /// When non-null, restrict to deployments whose instance belongs to one of these
@@ -33,12 +35,33 @@ namespace ZB.MOM.WW.ScadaBridge.Commons.Types.Deployment;
 /// "no filter"; <see langword="null"/> is the system-wide case.
 /// </param>
 /// <param name="InstanceId">Restrict to one instance's deployment history, or <see langword="null"/> for all.</param>
+/// <param name="SearchMode">Prefix (default, index-friendly) or bounded Contains. Only meaningful with <paramref name="Search"/>.</param>
+/// <param name="DeployedFrom">
+/// Lower bound on <c>DeployedAt</c>. Optional for Prefix searches; in Contains mode a
+/// window is ALWAYS applied: this value, or the last
+/// <see cref="DeploymentListFilter.ContainsDefaultWindow"/> when null.
+/// </param>
 public sealed record DeploymentListFilter(
     DeploymentStatus? Status = null,
     string? Search = null,
     IReadOnlyCollection<int>? SiteIdScope = null,
-    int? InstanceId = null)
+    int? InstanceId = null,
+    DeploymentSearchMode SearchMode = DeploymentSearchMode.Prefix,
+    DateTimeOffset? DeployedFrom = null)
 {
+    /// <summary>Time window applied to a Contains search that supplies no explicit <see cref="DeployedFrom"/>.</summary>
+    public static readonly TimeSpan ContainsDefaultWindow = TimeSpan.FromDays(30);
+
+    /// <summary>
+    /// The effective <c>DeployedAt</c> lower bound at <paramref name="nowUtc"/>: the explicit
+    /// <see cref="DeployedFrom"/>, else (Contains search only) now minus
+    /// <see cref="ContainsDefaultWindow"/>, else <see langword="null"/>.
+    /// </summary>
+    public DateTimeOffset? EffectiveDeployedFrom(DateTimeOffset nowUtc) =>
+        DeployedFrom ?? (NormalizedSearch is not null && SearchMode == DeploymentSearchMode.Contains
+            ? nowUtc - ContainsDefaultWindow
+            : null);
+
     /// <summary>
     /// The trimmed search term, or <see langword="null"/> when the term is absent
     /// or whitespace-only. Repository implementations use this rather than
@@ -48,3 +71,13 @@ public sealed record DeploymentListFilter(
     public string? NormalizedSearch =>
         string.IsNullOrWhiteSpace(Search) ? null : Search.Trim();
 }
+
+/// <summary>How <see cref="DeploymentListFilter.Search"/> is matched.</summary>
+public enum DeploymentSearchMode
+{
+    /// <summary>Case-insensitive prefix (<c>LIKE 'term%'</c>); can use the column indexes.</summary>
+    Prefix = 0,
+
+    /// <summary>Substring (<c>LIKE '%term%'</c>); scans, so it is always bounded by a DeployedAt window.</summary>
+    Contains = 1,
+}
diff --git a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Configurations/AuditConfiguration.cs b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Configurations/AuditConfiguration.cs
index 2f842ed4..83da3f94 100644
--- a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Configurations/AuditConfiguration.cs
+++ b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Configurations/AuditConfiguration.cs
@@ -40,6 +40,8 @@ public class AuditLogEntryConfiguration : IEntityTypeConfiguration<AuditLogEntry
         builder.HasIndex(a => a.EntityType);
         builder.HasIndex(a => a.EntityId);
         builder.HasIndex(a => a.Action);
+        // Prefix-search leg of the config-audit EntityName filter (ScadaBridge#50).
+        builder.HasIndex(a => a.EntityName).HasDatabaseName("IX_AuditLogEntries_EntityName");
         // Review-remediation composite indexes (ReviewRemediationIndexes). The single-column
         // Timestamp/User/EntityType indexes above are kept: (Timestamp DESC, Id DESC) only
         // subsumes Timestamp conceptually, and dropping existing indexes is deliberately
diff --git a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Configurations/DeploymentConfiguration.cs b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Configurations/DeploymentConfiguration.cs
index 28099c2c..0c2ba2fe 100644
--- a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Configurations/DeploymentConfiguration.cs
+++ b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Configurations/DeploymentConfiguration.cs
@@ -40,6 +40,11 @@ public class DeploymentRecordConfiguration : IEntityTypeConfiguration<Deployment
         builder.HasIndex(d => d.DeploymentId).IsUnique();
         builder.HasIndex(d => d.InstanceId);
 
+        // Prefix-search legs of the Deployments page free-text search (ScadaBridge#50):
+        // DeploymentId and Instance.UniqueName are already uniquely indexed.
+        builder.HasIndex(d => d.DeployedBy).HasDatabaseName("IX_DeploymentRecords_DeployedBy");
+        builder.HasIndex(d => d.RevisionHash).HasDatabaseName("IX_DeploymentRecords_RevisionHash");
+
         // Deployment-list sort key. Every list read orders DeployedAt DESC, Id DESC
         // (DeploymentManagerRepository.QueryDeploymentListPageAsync, which register
         // row 37 made the single paged read behind BOTH the Central UI page and the
diff --git a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/20261109203753_PrefixSearchIndexes.Designer.cs b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/20261109203753_PrefixSearchIndexes.Designer.cs
new file mode 100644
index 00000000..3029ab8e
--- /dev/null
+++ b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/20261109203753_PrefixSearchIndexes.Designer.cs
@@ -0,0 +1,2184 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using ZB.MOM.WW.ScadaBridge.ConfigurationDatabase;
+
+#nullable disable
+
+namespace ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Migrations
+{
+    [DbContext(typeof(ScadaBridgeDbContext))]
+    [Migration("20261109203753_PrefixSearchIndexes")]
+    partial class PrefixSearchIndexes
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.13")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("Microsoft.AspNetCore.DataProtection.EntityFrameworkCore.DataProtectionKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("FriendlyName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Xml")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("DataProtectionKeys");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Audit.AuditLogEntry", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("AfterStateJson")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid?>("BundleImportId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("EntityId")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("EntityName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("EntityType")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTimeOffset>("Timestamp")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("User")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Action");
+
+                    b.HasIndex("BundleImportId")
+                        .HasDatabaseName("IX_AuditLogEntries_BundleImportId");
+
+                    b.HasIndex("EntityId");
+
+                    b.HasIndex("EntityName")
+                        .HasDatabaseName("IX_AuditLogEntries_EntityName");
+
+                    b.HasIndex("EntityType");
+
+                    b.HasIndex("Timestamp");
+
+                    b.HasIndex("User");
+
+                    b.HasIndex("EntityType", "Timestamp")
+                        .IsDescending(false, true)
+                        .HasDatabaseName("IX_AuditLogEntries_EntityType_Timestamp");
+
+                    b.HasIndex("Timestamp", "Id")
+                        .IsDescending()
+                        .HasDatabaseName("IX_AuditLogEntries_Timestamp_Id");
+
+                    b.HasIndex("User", "Timestamp")
+                        .IsDescending(false, true)
+                        .HasDatabaseName("IX_AuditLogEntries_User_Timestamp");
+
+                    b.ToTable("AuditLogEntries");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Audit.SiteCall", b =>
+                {
+                    b.Property<string>("TrackedOperationId")
+                        .HasMaxLength(36)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(36)");
+
+                    b.Property<string>("Channel")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(32)");
+
+                    b.Property<DateTime>("CreatedAtUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<int?>("HttpStatus")
+                        .HasColumnType("int");
+
+                    b.Property<DateTime>("IngestedAtUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(1024)
+                        .HasColumnType("nvarchar(1024)");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("SourceNode")
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<string>("SourceSite")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(32)");
+
+                    b.Property<string>("Target")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(256)");
+
+                    b.Property<DateTime?>("TerminalAtUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime>("UpdatedAtUtc")
+                        .HasColumnType("datetime2");
+
+                    b.HasKey("TrackedOperationId");
+
+                    b.HasIndex("CreatedAtUtc")
+                        .HasDatabaseName("IX_SiteCalls_NonTerminal")
+                        .HasFilter("[TerminalAtUtc] IS NULL");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("CreatedAtUtc"), new[] { "SourceSite", "SourceNode", "Status" });
+
+                    b.HasIndex("TerminalAtUtc")
+                        .HasDatabaseName("IX_SiteCalls_Terminal")
+                        .HasFilter("[TerminalAtUtc] IS NOT NULL");
+
+                    b.HasIndex("CreatedAtUtc", "TrackedOperationId")
+                        .IsDescending()
+                        .HasDatabaseName("IX_SiteCalls_Created_TrackedOperationId");
+
+                    b.HasIndex("SourceSite", "CreatedAtUtc")
+                        .IsDescending(false, true)
+                        .HasDatabaseName("IX_SiteCalls_Source_Created");
+
+                    b.HasIndex("Status", "UpdatedAtUtc")
+                        .IsDescending(false, true)
+                        .HasDatabaseName("IX_SiteCalls_Status_Updated");
+
+                    b.ToTable("SiteCalls", (string)null);
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Deployment.DeployedConfigSnapshot", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConfigurationJson")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("DeployedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("DeploymentId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<int>("InstanceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RevisionHash")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeploymentId");
+
+                    b.HasIndex("InstanceId")
+                        .IsUnique();
+
+                    b.ToTable("DeployedConfigSnapshots");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Deployment.DeploymentRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTimeOffset?>("CompletedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset>("DeployedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("DeployedBy")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("DeploymentId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("ErrorMessage")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("InstanceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RevisionHash")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<byte[]>("RowVersion")
+                        .IsConcurrencyToken()
+                        .IsRequired()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("rowversion");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeployedBy")
+                        .HasDatabaseName("IX_DeploymentRecords_DeployedBy");
+
+                    b.HasIndex("DeploymentId")
+                        .IsUnique();
+
+                    b.HasIndex("InstanceId");
+
+                    b.HasIndex("RevisionHash")
+                        .HasDatabaseName("IX_DeploymentRecords_RevisionHash");
+
+                    b.HasIndex("DeployedAt", "Id")
+                        .IsDescending()
+                        .HasDatabaseName("IX_DeploymentRecords_DeployedAt_Id");
+
+                    b.ToTable("DeploymentRecords");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Deployment.PendingDeployment", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConfigurationJson")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreatedAtUtc")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("DeploymentId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTimeOffset>("ExpiresAtUtc")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<int>("InstanceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("RevisionHash")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Token")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("nvarchar(128)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeploymentId")
+                        .IsUnique();
+
+                    b.HasIndex("ExpiresAtUtc");
+
+                    b.HasIndex("InstanceId");
+
+                    b.ToTable("PendingDeployments", (string)null);
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Deployment.SystemArtifactDeploymentRecord", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ArtifactType")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTimeOffset>("DeployedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("DeployedBy")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("PerSiteStatus")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeployedAt");
+
+                    b.ToTable("SystemArtifactDeploymentRecords");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.ExternalSystems.DatabaseConnectionDefinition", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConnectionString")
+                        .IsRequired()
+                        .HasMaxLength(8000)
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("MaxRetries")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<TimeSpan>("RetryDelay")
+                        .HasColumnType("time");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("DatabaseConnectionDefinitions");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.ExternalSystems.ExternalSystemDefinition", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AuthConfiguration")
+                        .HasMaxLength(8000)
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("AuthType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("EndpointUrl")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<int>("MaxRetries")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<TimeSpan>("RetryDelay")
+                        .HasColumnType("time");
+
+                    b.Property<int>("TimeoutSeconds")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(0);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ExternalSystemDefinitions");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.ExternalSystems.ExternalSystemMethod", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ExternalSystemDefinitionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("HttpMethod")
+                        .IsRequired()
+                        .HasMaxLength(10)
+                        .HasColumnType("nvarchar(10)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("ParameterDefinitions")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("ReturnDefinition")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExternalSystemDefinitionId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("ExternalSystemMethods");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.InboundApi.ApiMethod", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("ParameterDefinitions")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("ReturnDefinition")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("Script")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("TimeoutSeconds")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("TraceAllCalls")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false);
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("ApiMethods");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Area", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int?>("ParentAreaId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SiteId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentAreaId");
+
+                    b.HasIndex("SiteId", "ParentAreaId", "Name")
+                        .IsUnique()
+                        .HasFilter("[ParentAreaId] IS NOT NULL");
+
+                    b.ToTable("Areas");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Instance", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("AreaId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SiteId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("State")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("UniqueName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AreaId");
+
+                    b.HasIndex("SiteId");
+
+                    b.HasIndex("TemplateId");
+
+                    b.HasIndex("UniqueName")
+                        .IsUnique();
+
+                    b.ToTable("Instances");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.InstanceAlarmOverride", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AlarmCanonicalName")
+                        .IsRequired()
+                        .HasMaxLength(400)
+                        .HasColumnType("nvarchar(400)");
+
+                    b.Property<int>("InstanceId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsMesReportableOverride")
+                        .HasColumnType("bit");
+
+                    b.Property<int?>("PriorityLevelOverride")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TriggerConfigurationOverride")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstanceId", "AlarmCanonicalName")
+                        .IsUnique();
+
+                    b.ToTable("InstanceAlarmOverrides");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.InstanceAttributeOverride", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AttributeName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("ElementDataType")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int>("InstanceId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OverrideValue")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstanceId", "AttributeName")
+                        .IsUnique();
+
+                    b.ToTable("InstanceAttributeOverrides");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.InstanceConnectionBinding", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AttributeName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("DataConnectionId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("DataSourceReferenceOverride")
+                        .HasMaxLength(512)
+                        .HasColumnType("nvarchar(512)");
+
+                    b.Property<int>("InstanceId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DataConnectionId");
+
+                    b.HasIndex("InstanceId", "AttributeName")
+                        .IsUnique();
+
+                    b.ToTable("InstanceConnectionBindings");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.InstanceNativeAlarmSourceOverride", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConditionFilterOverride")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("ConnectionNameOverride")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("InstanceId")
+                        .HasColumnType("int");
+
+                    b.Property<bool?>("IsMesReportableOverride")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("SourceCanonicalName")
+                        .IsRequired()
+                        .HasMaxLength(400)
+                        .HasColumnType("nvarchar(400)");
+
+                    b.Property<string>("SourceReferenceOverride")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("InstanceId", "SourceCanonicalName")
+                        .IsUnique();
+
+                    b.ToTable("InstanceNativeAlarmSourceOverrides");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Kpi.KpiRollupHourly", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("HourStartUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<double>("MaxValue")
+                        .HasColumnType("float");
+
+                    b.Property<string>("Metric")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<double>("MinValue")
+                        .HasColumnType("float");
+
+                    b.Property<int>("SampleCount")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Scope")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(16)");
+
+                    b.Property<string>("ScopeKey")
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<double>("Value")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("HourStartUtc")
+                        .HasDatabaseName("IX_KpiRollupHourly_Hour");
+
+                    b.HasIndex("Source", "Metric", "Scope", "ScopeKey", "HourStartUtc")
+                        .IsUnique()
+                        .HasDatabaseName("IX_KpiRollupHourly_Series");
+
+                    b.ToTable("KpiRollupHourly", (string)null);
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Kpi.KpiSample", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CapturedAtUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Metric")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<string>("Scope")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(16)");
+
+                    b.Property<string>("ScopeKey")
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<string>("Source")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<double>("Value")
+                        .HasColumnType("float");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CapturedAtUtc")
+                        .HasDatabaseName("IX_KpiSample_Captured");
+
+                    b.HasIndex("Source", "Metric", "Scope", "ScopeKey", "CapturedAtUtc")
+                        .HasDatabaseName("IX_KpiSample_Series");
+
+                    b.ToTable("KpiSample", (string)null);
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications.Notification", b =>
+                {
+                    b.Property<string>("NotificationId")
+                        .HasMaxLength(64)
+                        .HasColumnType("nvarchar(64)");
+
+                    b.Property<string>("Body")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTimeOffset>("CreatedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("DeliveredAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<DateTimeOffset?>("LastAttemptAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("LastError")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("ListName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<DateTimeOffset?>("NextAttemptAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<Guid?>("OriginExecutionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<Guid?>("OriginParentExecutionId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("ResolvedTargets")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("RetryCount")
+                        .HasColumnType("int");
+
+                    b.Property<DateTimeOffset>("SiteEnqueuedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("SourceInstanceId")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("SourceNode")
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<string>("SourceScript")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("SourceSiteId")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("nvarchar(32)");
+
+                    b.Property<string>("Subject")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("nvarchar(32)");
+
+                    b.Property<string>("TypeData")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("NotificationId");
+
+                    b.HasIndex("DeliveredAt")
+                        .HasDatabaseName("IX_Notifications_Delivered")
+                        .HasFilter("[Status] = 'Delivered'");
+
+                    b.HasIndex("CreatedAt", "NotificationId")
+                        .IsDescending()
+                        .HasDatabaseName("IX_Notifications_Created_NotificationId");
+
+                    b.HasIndex("SourceSiteId", "CreatedAt");
+
+                    b.HasIndex("Status", "NextAttemptAt");
+
+                    b.ToTable("Notifications");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications.NotificationList", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("nvarchar(32)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("NotificationLists");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications.NotificationRecipient", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("EmailAddress")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("NotificationListId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasMaxLength(32)
+                        .HasColumnType("nvarchar(32)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NotificationListId");
+
+                    b.ToTable("NotificationRecipients");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications.SmsConfiguration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AccountSid")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("ApiBaseUrl")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("AuthToken")
+                        .HasMaxLength(8000)
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("ConnectionTimeoutSeconds")
+                        .HasColumnType("int");
+
+                    b.Property<string>("FromNumber")
+                        .HasMaxLength(32)
+                        .HasColumnType("nvarchar(32)");
+
+                    b.Property<int>("MaxRetries")
+                        .HasColumnType("int");
+
+                    b.Property<string>("MessagingServiceSid")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<TimeSpan>("RetryDelay")
+                        .HasColumnType("time");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SmsConfigurations");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications.SmtpConfiguration", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AuthType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int>("ConnectionTimeoutSeconds")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Credentials")
+                        .HasMaxLength(8000)
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("FromAddress")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Host")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("MaxConcurrentConnections")
+                        .HasColumnType("int");
+
+                    b.Property<int>("MaxRetries")
+                        .HasColumnType("int");
+
+                    b.Property<string>("OAuth2Authority")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("OAuth2Scope")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<int>("Port")
+                        .HasColumnType("int");
+
+                    b.Property<TimeSpan>("RetryDelay")
+                        .HasColumnType("time");
+
+                    b.Property<string>("TlsMode")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Transport")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SmtpConfigurations");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Schemas.SharedSchema", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("SchemaJson")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Scope")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("SharedSchemas");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Scripts.SharedScript", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("ParameterDefinitions")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("ReturnDefinition")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("SharedScripts");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.SecuredWrites.PendingSecuredWrite", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("ConnectionName")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(128)");
+
+                    b.Property<DateTime?>("DecidedAtUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ExecutedAtUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ExecutionError")
+                        .HasMaxLength(2048)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(2048)");
+
+                    b.Property<string>("OperatorComment")
+                        .HasMaxLength(1024)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(1024)");
+
+                    b.Property<string>("OperatorUser")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(256)");
+
+                    b.Property<string>("SiteId")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(128)");
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(32)");
+
+                    b.Property<DateTime>("SubmittedAtUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("TagPath")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(512)");
+
+                    b.Property<string>("ValueJson")
+                        .IsRequired()
+                        .HasMaxLength(4000)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(4000)");
+
+                    b.Property<string>("ValueType")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(128)");
+
+                    b.Property<string>("VerifierComment")
+                        .HasMaxLength(1024)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(1024)");
+
+                    b.Property<string>("VerifierUser")
+                        .HasMaxLength(256)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SiteId")
+                        .HasDatabaseName("IX_PendingSecuredWrites_Site");
+
+                    b.HasIndex("Status", "SubmittedAtUtc")
+                        .HasDatabaseName("IX_PendingSecuredWrites_Status_Submitted");
+
+                    b.ToTable("PendingSecuredWrites", (string)null);
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Security.LdapGroupMapping", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("LdapGroupName")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Role")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("LdapGroupName")
+                        .IsUnique();
+
+                    b.ToTable("LdapGroupMappings");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1,
+                            LdapGroupName = "SCADA-Admins",
+                            Role = "Administrator"
+                        },
+                        new
+                        {
+                            Id = 2,
+                            LdapGroupName = "SCADA-Designers",
+                            Role = "Designer"
+                        },
+                        new
+                        {
+                            Id = 3,
+                            LdapGroupName = "SCADA-Deploy-All",
+                            Role = "Deployer"
+                        },
+                        new
+                        {
+                            Id = 4,
+                            LdapGroupName = "SCADA-Deploy-SiteA",
+                            Role = "Deployer"
+                        },
+                        new
+                        {
+                            Id = 5,
+                            LdapGroupName = "SCADA-Viewers",
+                            Role = "Viewer"
+                        });
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Security.SiteScopeRule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("LdapGroupMappingId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SiteId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SiteId");
+
+                    b.HasIndex("LdapGroupMappingId", "SiteId")
+                        .IsUnique();
+
+                    b.ToTable("SiteScopeRules");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites.DataConnection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("BackupConfiguration")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int>("FailoverRetryCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(3);
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("PrimaryConfiguration")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Protocol")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<int>("SiteId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SiteId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("DataConnections");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites.Site", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ArtifactRevisionHash")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<DateTimeOffset?>("ArtifactsDeployedAt")
+                        .HasColumnType("datetimeoffset");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("GrpcNodeAAddress")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("GrpcNodeBAddress")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("NodeAAddress")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("NodeBAddress")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("SiteIdentifier")
+                        .IsRequired()
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.HasIndex("SiteIdentifier")
+                        .IsUnique();
+
+                    b.ToTable("Sites");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<int?>("FolderId")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsDerived")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int?>("OwnerCompositionId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("ParentTemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FolderId");
+
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasFilter("[IsDerived] = 0");
+
+                    b.HasIndex("ParentTemplateId");
+
+                    b.ToTable("Templates");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateAlarm", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<bool>("IsInherited")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsLocked")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsMesReportable")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockedInDerived")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int?>("OnTriggerScriptId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("PriorityLevel")
+                        .HasColumnType("int");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TriggerConfiguration")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("TriggerType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TemplateId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("TemplateAlarms");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateAttribute", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("DataSourceReference")
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)");
+
+                    b.Property<string>("DataType")
+                        .IsRequired()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<string>("ElementDataType")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<bool>("IsInherited")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsLocked")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockedInDerived")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TemplateId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("TemplateAttributes");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateComposition", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ComposedTemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("InstanceName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ComposedTemplateId");
+
+                    b.HasIndex("TemplateId", "InstanceName")
+                        .IsUnique();
+
+                    b.ToTable("TemplateCompositions");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateFolder", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<int?>("ParentFolderId")
+                        .HasColumnType("int");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ParentFolderId", "Name")
+                        .IsUnique()
+                        .HasFilter("[ParentFolderId] IS NOT NULL");
+
+                    b.ToTable("TemplateFolders");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateNativeAlarmSource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ConditionFilter")
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<string>("ConnectionName")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(2000)
+                        .HasColumnType("nvarchar(2000)");
+
+                    b.Property<bool>("IsInherited")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsLocked")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsMesReportable")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockedInDerived")
+                        .HasColumnType("bit");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("SourceReference")
+                        .IsRequired()
+                        .HasMaxLength(1000)
+                        .HasColumnType("nvarchar(1000)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TemplateId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("TemplateNativeAlarmSources");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateScript", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Code")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<int?>("ExecutionTimeoutSeconds")
+                        .HasColumnType("int");
+
+                    b.Property<bool>("IsInherited")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("IsLocked")
+                        .HasColumnType("bit");
+
+                    b.Property<bool>("LockedInDerived")
+                        .HasColumnType("bit");
+
+                    b.Property<TimeSpan?>("MinTimeBetweenRuns")
+                        .HasColumnType("time");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("ParameterDefinitions")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("ReturnDefinition")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<int>("TemplateId")
+                        .HasColumnType("int");
+
+                    b.Property<string>("TriggerConfiguration")
+                        .HasMaxLength(4000)
+                        .HasColumnType("nvarchar(4000)");
+
+                    b.Property<string>("TriggerType")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TemplateId", "Name")
+                        .IsUnique();
+
+                    b.ToTable("TemplateScripts");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Transport.BundleUnlockAttempt", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("AttemptedAtUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ClientKey")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientKey", "AttemptedAtUtc")
+                        .HasDatabaseName("IX_BundleUnlockAttempt_Client_Attempted");
+
+                    b.ToTable("BundleUnlockAttempt", (string)null);
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Entities.AuditLogRow", b =>
+                {
+                    b.Property<Guid>("EventId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<DateTime>("OccurredAtUtc")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Action")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<string>("Actor")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.Property<string>("Channel")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(32)")
+                        .HasColumnName("Category");
+
+                    b.Property<Guid?>("CorrelationId")
+                        .HasColumnType("uniqueidentifier");
+
+                    b.Property<string>("DetailsJson")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<Guid?>("ExecutionId")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("uniqueidentifier")
+                        .HasComputedColumnSql("CAST(JSON_VALUE(DetailsJson,'$.executionId') AS uniqueidentifier)", true);
+
+                    b.Property<DateTime?>("IngestedAtUtc")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("datetime2(7)")
+                        .HasComputedColumnSql("CAST(SWITCHOFFSET(CAST(JSON_VALUE(DetailsJson,'$.ingestedAtUtc') AS datetimeoffset), 0) AS datetime2(7))", false);
+
+                    b.Property<string>("Kind")
+                        .IsRequired()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasMaxLength(32)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(32)")
+                        .HasComputedColumnSql("JSON_VALUE(DetailsJson,'$.kind')", true);
+
+                    b.Property<string>("Outcome")
+                        .IsRequired()
+                        .HasMaxLength(16)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(16)");
+
+                    b.Property<Guid?>("ParentExecutionId")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasColumnType("uniqueidentifier")
+                        .HasComputedColumnSql("CAST(JSON_VALUE(DetailsJson,'$.parentExecutionId') AS uniqueidentifier)", true);
+
+                    b.Property<string>("SourceNode")
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)");
+
+                    b.Property<string>("SourceSiteId")
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasMaxLength(64)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(64)")
+                        .HasComputedColumnSql("JSON_VALUE(DetailsJson,'$.sourceSiteId')", true);
+
+                    b.Property<string>("Status")
+                        .IsRequired()
+                        .ValueGeneratedOnAddOrUpdate()
+                        .HasMaxLength(32)
+                        .IsUnicode(false)
+                        .HasColumnType("varchar(32)")
+                        .HasComputedColumnSql("JSON_VALUE(DetailsJson,'$.status')", true);
+
+                    b.Property<string>("Target")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)");
+
+                    b.HasKey("EventId", "OccurredAtUtc");
+
+                    b.HasIndex("CorrelationId")
+                        .HasDatabaseName("IX_AuditLog_CorrelationId")
+                        .HasFilter("[CorrelationId] IS NOT NULL");
+
+                    b.HasIndex("ExecutionId")
+                        .HasDatabaseName("IX_AuditLog_Execution");
+
+                    b.HasIndex("OccurredAtUtc")
+                        .IsDescending()
+                        .HasDatabaseName("IX_AuditLog_OccurredAtUtc");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("OccurredAtUtc"), new[] { "Status" });
+
+                    b.HasIndex("ParentExecutionId")
+                        .HasDatabaseName("IX_AuditLog_ParentExecution");
+
+                    b.HasIndex("Actor", "OccurredAtUtc")
+                        .IsDescending(false, true)
+                        .HasDatabaseName("IX_AuditLog_Actor_Occurred");
+
+                    b.HasIndex("Kind", "OccurredAtUtc")
+                        .IsDescending(false, true)
+                        .HasDatabaseName("IX_AuditLog_Kind_Occurred");
+
+                    b.HasIndex("SourceNode", "OccurredAtUtc")
+                        .HasDatabaseName("IX_AuditLog_Node_Occurred");
+
+                    b.HasIndex("SourceSiteId", "OccurredAtUtc")
+                        .IsDescending(false, true)
+                        .HasDatabaseName("IX_AuditLog_Site_Occurred");
+
+                    b.HasIndex("Target", "OccurredAtUtc")
+                        .IsDescending(false, true)
+                        .HasDatabaseName("IX_AuditLog_Target_Occurred")
+                        .HasFilter("[Target] IS NOT NULL");
+
+                    b.HasIndex("Channel", "Status", "OccurredAtUtc")
+                        .IsDescending(false, false, true)
+                        .HasDatabaseName("IX_AuditLog_Channel_Status_Occurred");
+
+                    b.ToTable("AuditLog", (string)null);
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Deployment.DeployedConfigSnapshot", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Instance", null)
+                        .WithMany()
+                        .HasForeignKey("InstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Deployment.DeploymentRecord", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Instance", null)
+                        .WithMany()
+                        .HasForeignKey("InstanceId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Deployment.PendingDeployment", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Instance", null)
+                        .WithMany()
+                        .HasForeignKey("InstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.ExternalSystems.ExternalSystemMethod", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.ExternalSystems.ExternalSystemDefinition", null)
+                        .WithMany()
+                        .HasForeignKey("ExternalSystemDefinitionId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Area", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Area", null)
+                        .WithMany("Children")
+                        .HasForeignKey("ParentAreaId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites.Site", null)
+                        .WithMany()
+                        .HasForeignKey("SiteId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Instance", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Area", null)
+                        .WithMany()
+                        .HasForeignKey("AreaId")
+                        .OnDelete(DeleteBehavior.SetNull);
+
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites.Site", null)
+                        .WithMany()
+                        .HasForeignKey("SiteId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", null)
+                        .WithMany()
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.InstanceAlarmOverride", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Instance", null)
+                        .WithMany("AlarmOverrides")
+                        .HasForeignKey("InstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.InstanceAttributeOverride", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Instance", null)
+                        .WithMany("AttributeOverrides")
+                        .HasForeignKey("InstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.InstanceConnectionBinding", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites.DataConnection", null)
+                        .WithMany()
+                        .HasForeignKey("DataConnectionId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Instance", null)
+                        .WithMany("ConnectionBindings")
+                        .HasForeignKey("InstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.InstanceNativeAlarmSourceOverride", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Instance", null)
+                        .WithMany("NativeAlarmSourceOverrides")
+                        .HasForeignKey("InstanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications.NotificationRecipient", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications.NotificationList", null)
+                        .WithMany("Recipients")
+                        .HasForeignKey("NotificationListId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Security.SiteScopeRule", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Security.LdapGroupMapping", null)
+                        .WithMany()
+                        .HasForeignKey("LdapGroupMappingId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites.Site", null)
+                        .WithMany()
+                        .HasForeignKey("SiteId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites.DataConnection", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites.Site", null)
+                        .WithMany()
+                        .HasForeignKey("SiteId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateFolder", null)
+                        .WithMany()
+                        .HasForeignKey("FolderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", null)
+                        .WithMany()
+                        .HasForeignKey("ParentTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict);
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateAlarm", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", null)
+                        .WithMany("Alarms")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateAttribute", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", null)
+                        .WithMany("Attributes")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateComposition", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", null)
+                        .WithMany()
+                        .HasForeignKey("ComposedTemplateId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", null)
+                        .WithMany("Compositions")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateFolder", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateFolder", null)
+                        .WithMany()
+                        .HasForeignKey("ParentFolderId")
+                        .OnDelete(DeleteBehavior.Restrict);
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateNativeAlarmSource", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", null)
+                        .WithMany("NativeAlarmSources")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.TemplateScript", b =>
+                {
+                    b.HasOne("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", null)
+                        .WithMany("Scripts")
+                        .HasForeignKey("TemplateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Area", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances.Instance", b =>
+                {
+                    b.Navigation("AlarmOverrides");
+
+                    b.Navigation("AttributeOverrides");
+
+                    b.Navigation("ConnectionBindings");
+
+                    b.Navigation("NativeAlarmSourceOverrides");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Notifications.NotificationList", b =>
+                {
+                    b.Navigation("Recipients");
+                });
+
+            modelBuilder.Entity("ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates.Template", b =>
+                {
+                    b.Navigation("Alarms");
+
+                    b.Navigation("Attributes");
+
+                    b.Navigation("Compositions");
+
+                    b.Navigation("NativeAlarmSources");
+
+                    b.Navigation("Scripts");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/20261109203753_PrefixSearchIndexes.cs b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/20261109203753_PrefixSearchIndexes.cs
new file mode 100644
index 00000000..7dc682ff
--- /dev/null
+++ b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/20261109203753_PrefixSearchIndexes.cs
@@ -0,0 +1,45 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Migrations
+{
+    /// <inheritdoc />
+    public partial class PrefixSearchIndexes : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_DeploymentRecords_DeployedBy",
+                table: "DeploymentRecords",
+                column: "DeployedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_DeploymentRecords_RevisionHash",
+                table: "DeploymentRecords",
+                column: "RevisionHash");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_AuditLogEntries_EntityName",
+                table: "AuditLogEntries",
+                column: "EntityName");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_DeploymentRecords_DeployedBy",
+                table: "DeploymentRecords");
+
+            migrationBuilder.DropIndex(
+                name: "IX_DeploymentRecords_RevisionHash",
+                table: "DeploymentRecords");
+
+            migrationBuilder.DropIndex(
+                name: "IX_AuditLogEntries_EntityName",
+                table: "AuditLogEntries");
+        }
+    }
+}
diff --git a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/ScadaBridgeDbContextModelSnapshot.cs b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/ScadaBridgeDbContextModelSnapshot.cs
index 88fede6e..2dfe2da7 100644
--- a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/ScadaBridgeDbContextModelSnapshot.cs
+++ b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Migrations/ScadaBridgeDbContextModelSnapshot.cs
@@ -92,6 +92,9 @@ namespace ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Migrations
 
                     b.HasIndex("EntityId");
 
+                    b.HasIndex("EntityName")
+                        .HasDatabaseName("IX_AuditLogEntries_EntityName");
+
                     b.HasIndex("EntityType");
 
                     b.HasIndex("Timestamp");
@@ -283,11 +286,17 @@ namespace ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Migrations
 
                     b.HasKey("Id");
 
+                    b.HasIndex("DeployedBy")
+                        .HasDatabaseName("IX_DeploymentRecords_DeployedBy");
+
                     b.HasIndex("DeploymentId")
                         .IsUnique();
 
                     b.HasIndex("InstanceId");
 
+                    b.HasIndex("RevisionHash")
+                        .HasDatabaseName("IX_DeploymentRecords_RevisionHash");
+
                     b.HasIndex("DeployedAt", "Id")
                         .IsDescending()
                         .HasDatabaseName("IX_DeploymentRecords_DeployedAt_Id");
diff --git a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/CentralUiRepository.cs b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/CentralUiRepository.cs
index 3bdee77b..af2e0220 100644
--- a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/CentralUiRepository.cs
+++ b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/CentralUiRepository.cs
@@ -127,33 +127,12 @@ public class CentralUiRepository : ICentralUiRepository
         Guid? bundleImportId = null,
         int page = 1,
         int pageSize = 50,
-        CancellationToken cancellationToken = default)
+        CancellationToken cancellationToken = default,
+        bool entityNameContains = false)
     {
-        var query = _context.AuditLogEntries.AsNoTracking().AsQueryable();
-
-        if (!string.IsNullOrWhiteSpace(user))
-            query = query.Where(a => a.User == user);
-
-        if (!string.IsNullOrWhiteSpace(entityType))
-            query = query.Where(a => a.EntityType == entityType);
-
-        if (!string.IsNullOrWhiteSpace(action))
-            query = query.Where(a => a.Action == action);
-
-        if (from.HasValue)
-            query = query.Where(a => a.Timestamp >= from.Value);
-
-        if (to.HasValue)
-            query = query.Where(a => a.Timestamp <= to.Value);
-
-        if (!string.IsNullOrWhiteSpace(entityId))
-            query = query.Where(a => a.EntityId == entityId);
-
-        if (!string.IsNullOrWhiteSpace(entityName))
-            query = query.Where(a => a.EntityName.Contains(entityName));
-
-        if (bundleImportId is Guid bundleId)
-            query = query.Where(a => a.BundleImportId == bundleId);
+        var query = BuildAuditLogQuery(
+            user, entityType, action, from, to, entityId, entityName, bundleImportId,
+            entityNameContains, DateTimeOffset.UtcNow);
 
         var totalCount = await query.CountAsync(cancellationToken);
 
@@ -169,6 +148,51 @@ public class CentralUiRepository : ICentralUiRepository
         return (entries, totalCount);
     }
 
+    /// <summary>Default window for an opt-in entity-name substring search with no explicit <c>from</c>.</summary>
+    internal static readonly TimeSpan EntityNameContainsDefaultWindow = TimeSpan.FromDays(30);
+
+    internal IQueryable<AuditLogEntry> BuildAuditLogQuery(
+        string? user, string? entityType, string? action, DateTimeOffset? from, DateTimeOffset? to,
+        string? entityId, string? entityName, Guid? bundleImportId, bool entityNameContains, DateTimeOffset nowUtc)
+    {
+        var query = _context.AuditLogEntries.AsNoTracking().AsQueryable();
+
+        if (!string.IsNullOrWhiteSpace(user))
+            query = query.Where(a => a.User == user);
+
+        if (!string.IsNullOrWhiteSpace(entityType))
+            query = query.Where(a => a.EntityType == entityType);
+
+        if (!string.IsNullOrWhiteSpace(action))
+            query = query.Where(a => a.Action == action);
+
+        // A substring name search scans, so it is never unbounded: without an explicit
+        // `from` it is limited to the last EntityNameContainsDefaultWindow (ScadaBridge#50).
+        var contains = entityNameContains && !string.IsNullOrWhiteSpace(entityName);
+        var effectiveFrom = from ?? (contains ? nowUtc - EntityNameContainsDefaultWindow : (DateTimeOffset?)null);
+        if (effectiveFrom.HasValue)
+        {
+            var lowerBound = effectiveFrom.Value;
+            query = query.Where(a => a.Timestamp >= lowerBound);
+        }
+
+        if (to.HasValue)
+            query = query.Where(a => a.Timestamp <= to.Value);
+
+        if (!string.IsNullOrWhiteSpace(entityId))
+            query = query.Where(a => a.EntityId == entityId);
+
+        if (!string.IsNullOrWhiteSpace(entityName))
+            query = contains
+                ? query.Where(a => a.EntityName.Contains(entityName))
+                : query.Where(a => a.EntityName.StartsWith(entityName));
+
+        if (bundleImportId is Guid bundleId)
+            query = query.Where(a => a.BundleImportId == bundleId);
+
+        return query;
+    }
+
     /// <inheritdoc />
     public async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
     {
diff --git a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/DeploymentManagerRepository.cs b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/DeploymentManagerRepository.cs
index 255f2245..435252ec 100644
--- a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/DeploymentManagerRepository.cs
+++ b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/Repositories/DeploymentManagerRepository.cs
@@ -57,7 +57,7 @@ public class DeploymentManagerRepository : IDeploymentManagerRepository
     /// status-count aggregation needs every status of the otherwise-identical set.
     /// </param>
     /// <returns>The composed, unordered, untracked query.</returns>
-    private IQueryable<DeploymentInstanceJoin> BuildListQuery(DeploymentListFilter filter, bool applyStatus)
+    internal IQueryable<DeploymentInstanceJoin> BuildListQuery(DeploymentListFilter filter, bool applyStatus)
     {
         ArgumentNullException.ThrowIfNull(filter);
 
@@ -93,16 +93,26 @@ public class DeploymentManagerRepository : IDeploymentManagerRepository
             query = query.Where(r => scope.Contains(r.SiteId));
         }
 
+        if (filter.EffectiveDeployedFrom(DateTimeOffset.UtcNow) is { } from)
+            query = query.Where(r => r.DeployedAt >= from);
+
         if (filter.NormalizedSearch is { } search)
         {
-            // Substring match across the four identifiers a deployment is findable
-            // by. Translated to LIKE '%term%' by both providers; case-insensitivity
-            // is the database collation's (SQL Server default CI, SQLite ASCII LIKE).
-            query = query.Where(r =>
-                r.InstanceUniqueName.Contains(search)
-                || r.DeploymentId.Contains(search)
-                || r.DeployedBy.Contains(search)
-                || (r.RevisionHash != null && r.RevisionHash.Contains(search)));
+            // Default: PREFIX match across the four identifiers a deployment is findable
+            // by (LIKE 'term%', index-seekable; case-insensitivity is the database
+            // collation's). Contains is the explicit opt-in scan (LIKE '%term%') and is
+            // always bounded by the DeployedAt window applied above (ScadaBridge#50).
+            query = filter.SearchMode == DeploymentSearchMode.Contains
+                ? query.Where(r =>
+                    r.InstanceUniqueName.Contains(search)
+                    || r.DeploymentId.Contains(search)
+                    || r.DeployedBy.Contains(search)
+                    || (r.RevisionHash != null && r.RevisionHash.Contains(search)))
+                : query.Where(r =>
+                    r.InstanceUniqueName.StartsWith(search)
+                    || r.DeploymentId.StartsWith(search)
+                    || r.DeployedBy.StartsWith(search)
+                    || (r.RevisionHash != null && r.RevisionHash.StartsWith(search)));
         }
 
         return query;
@@ -873,7 +883,7 @@ public class DeploymentManagerRepository : IDeploymentManagerRepository
     /// lockstep. Not a public contract — <see cref="DeploymentListRow"/> is what
     /// leaves this class.
     /// </summary>
-    private sealed class DeploymentInstanceJoin
+    internal sealed class DeploymentInstanceJoin
     {
         /// <summary>Deployment record primary key.</summary>
         public int Id { get; init; }
diff --git a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.csproj b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.csproj
index d81a1537..acf9f91c 100644
--- a/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.csproj
+++ b/src/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.csproj
@@ -7,6 +7,10 @@
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
   </PropertyGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Microsoft.EntityFrameworkCore" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" />
diff --git a/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/DeploymentListQueryRepositoryTests.cs b/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/DeploymentListQueryRepositoryTests.cs
index 9337164f..2c7ee68a 100644
--- a/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/DeploymentListQueryRepositoryTests.cs
+++ b/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/DeploymentListQueryRepositoryTests.cs
@@ -258,7 +258,7 @@ public class DeploymentListQueryRepositoryTests : IDisposable
     /// <param name="expected">The expected.</param>
     /// <returns>A task that represents the asynchronous operation.</returns>
     [Theory]
-    [InlineData("Filler", "dep-a")]     // instance unique name
+    [InlineData("Line3", "dep-a")]      // instance unique name (prefix)
     [InlineData("dep-b", "dep-b")]      // deployment id
     [InlineData("carol", "dep-b")]      // initiating user
     [InlineData("rev-a", "dep-a")]      // revision hash
diff --git a/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/SearchPrefixQueryTests.cs b/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/SearchPrefixQueryTests.cs
new file mode 100644
index 00000000..5a9d9a83
--- /dev/null
+++ b/tests/ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests/SearchPrefixQueryTests.cs
@@ -0,0 +1,201 @@
+using Microsoft.EntityFrameworkCore;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Audit;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Deployment;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Sites;
+using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Deployment;
+using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums;
+using ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Repositories;
+
+namespace ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Tests;
+
+/// <summary>
+/// ScadaBridge#50: the Deployments and config-audit free-text searches must not use a
+/// leading-wildcard LIKE by default. Query-shape tests render the SQL Server provider's SQL
+/// (no connection needed); result tests run on SQLite.
+/// </summary>
+public class SearchPrefixQueryTests : IDisposable
+{
+    private readonly ScadaBridgeDbContext _context = SqliteTestHelper.CreateInMemoryContext();
+    private readonly DeploymentManagerRepository _deployments;
+    private readonly CentralUiRepository _audit;
+
+    /// <summary>Initializes a new instance of the <c>SearchPrefixQueryTests</c> class.</summary>
+    public SearchPrefixQueryTests()
+    {
+        _deployments = new DeploymentManagerRepository(_context);
+        _audit = new CentralUiRepository(_context);
+    }
+
+    /// <summary>Releases the resources held by the test fixture.</summary>
+    public void Dispose()
+    {
+        _context.Database.CloseConnection();
+        _context.Dispose();
+        GC.SuppressFinalize(this);
+    }
+
+    private static ScadaBridgeDbContext SqlServerContext() =>
+        new(new DbContextOptionsBuilder<ScadaBridgeDbContext>()
+            .UseSqlServer("Server=unused;Database=unused;")
+            .Options);
+
+    // ── Query shape (SQL Server SQL) ─────────────────────────────────────────
+
+    /// <summary>Default deployment search renders a trailing-wildcard-only LIKE and no time window.</summary>
+    [Fact]
+    public void Deployments_DefaultSearch_HasNoLeadingWildcard()
+    {
+        using var ctx = SqlServerContext();
+        var sql = new DeploymentManagerRepository(ctx)
+            .BuildListQuery(new DeploymentListFilter(Search: "Line3"), applyStatus: true)
+            .ToQueryString();
+
+        // EF parameterises the LIKE pattern: assert on the declared pattern values.
+        Assert.Contains("LIKE @search_startswith ESCAPE", sql);
+        Assert.Contains("= N'Line3%';", sql);
+        Assert.DoesNotContain("= N'%", sql);
+        Assert.DoesNotContain("_contains", sql);
+        Assert.DoesNotContain("DeployedAt] >=", sql);
+    }
+
+    /// <summary>The Contains opt-in keeps the substring scan but is always time-bounded.</summary>
+    [Fact]
+    public void Deployments_ContainsSearch_HasLeadingWildcard_AndIsTimeBounded()
+    {
+        using var ctx = SqlServerContext();
+        var sql = new DeploymentManagerRepository(ctx)
+            .BuildListQuery(new DeploymentListFilter(Search: "Filler", SearchMode: DeploymentSearchMode.Contains), applyStatus: true)
+            .ToQueryString();
+
+        Assert.Contains("= N'%Filler%';", sql);
+        Assert.Contains("_contains", sql);
+        Assert.Contains("DeployedAt] >=", sql);
+    }
+
+    /// <summary>Default audit entity-name filter is a prefix match with no window.</summary>
+    [Fact]
+    public void AuditLog_DefaultEntityName_HasNoLeadingWildcard_NoWindow()
+    {
+        using var ctx = SqlServerContext();
+        var sql = new CentralUiRepository(ctx)
+            .BuildAuditLogQuery(null, null, null, null, null, null, "Pump", null, false, DateTimeOffset.UtcNow)
+            .ToQueryString();
+
+        Assert.Contains("LIKE @entityName_startswith ESCAPE", sql);
+        Assert.Contains("= N'Pump%';", sql);
+        Assert.DoesNotContain("= N'%", sql);
+        Assert.DoesNotContain("[Timestamp] >=", sql);
+    }
+
+    /// <summary>The audit Contains opt-in is bounded by the default window.</summary>
+    [Fact]
+    public void AuditLog_ContainsEntityName_IsBoundedByDefaultWindow()
+    {
+        using var ctx = SqlServerContext();
+        var sql = new CentralUiRepository(ctx)
+            .BuildAuditLogQuery(null, null, null, null, null, null, "Pump", null, true, DateTimeOffset.UtcNow)
+            .ToQueryString();
+
+        Assert.Contains("= N'%Pump%';", sql);
+        Assert.Contains("[Timestamp] >=", sql);
+    }
+
+    /// <summary>The effective window applies only to Contains searches or an explicit bound.</summary>
+    [Fact]
+    public void EffectiveDeployedFrom_OnlyForContains_OrExplicit()
+    {
+        var now = new DateTimeOffset(2026, 11, 9, 0, 0, 0, TimeSpan.Zero);
+        Assert.Null(new DeploymentListFilter(Search: "x").EffectiveDeployedFrom(now));
+        Assert.Null(new DeploymentListFilter(SearchMode: DeploymentSearchMode.Contains).EffectiveDeployedFrom(now));
+        Assert.Equal(now.AddDays(-30),
+            new DeploymentListFilter(Search: "x", SearchMode: DeploymentSearchMode.Contains).EffectiveDeployedFrom(now));
+        var explicitFrom = now.AddDays(-2);
+        Assert.Equal(explicitFrom,
+            new DeploymentListFilter(Search: "x", SearchMode: DeploymentSearchMode.Contains, DeployedFrom: explicitFrom).EffectiveDeployedFrom(now));
+    }
+
+    // ── Results (SQLite) ─────────────────────────────────────────────────────
+
+    private async Task SeedDeploymentsAsync()
+    {
+        var site = new Site("S1", "S1");
+        _context.Sites.Add(site);
+        var template = new Template("T");
+        _context.Templates.Add(template);
+        await _context.SaveChangesAsync();
+        var a = new Instance("Line3.Filler") { SiteId = site.Id, TemplateId = template.Id };
+        var b = new Instance("Line4.Filler") { SiteId = site.Id, TemplateId = template.Id };
+        _context.Instances.AddRange(a, b);
+        await _context.SaveChangesAsync();
+
+        _context.DeploymentRecords.AddRange(
+            new DeploymentRecord("dep-old", "alice") { InstanceId = a.Id, Status = DeploymentStatus.Success, DeployedAt = DateTimeOffset.UtcNow.AddDays(-90) },
+            new DeploymentRecord("dep-new", "alice") { InstanceId = b.Id, Status = DeploymentStatus.Success, DeployedAt = DateTimeOffset.UtcNow.AddDays(-1) });
+        await _context.SaveChangesAsync();
+    }
+
+    /// <summary>Prefix search does not match mid-string, is case-insensitive, finds the prefix.</summary>
+    [Fact]
+    public async Task Deployments_Prefix_DoesNotMatchInTheMiddle()
+    {
+        await SeedDeploymentsAsync();
+
+        var mid = await _deployments.QueryDeploymentListPageAsync(new DeploymentListFilter(Search: "Filler"), 1, 25);
+        Assert.Equal(0, mid.TotalCount);
+
+        var prefix = await _deployments.QueryDeploymentListPageAsync(new DeploymentListFilter(Search: "line3"), 1, 25);
+        Assert.Equal("dep-old", Assert.Single(prefix.Rows).DeploymentId);
+    }
+
+    /// <summary>Contains matches mid-string but only inside the window; counts agree.</summary>
+    [Fact]
+    public async Task Deployments_Contains_MatchesInTheMiddle_ButOnlyWithinTheWindow()
+    {
+        await SeedDeploymentsAsync();
+
+        var page = await _deployments.QueryDeploymentListPageAsync(
+            new DeploymentListFilter(Search: "Filler", SearchMode: DeploymentSearchMode.Contains), 1, 25);
+        Assert.Equal("dep-new", Assert.Single(page.Rows).DeploymentId);
+
+        var wide = await _deployments.QueryDeploymentListPageAsync(
+            new DeploymentListFilter(Search: "Filler", SearchMode: DeploymentSearchMode.Contains,
+                DeployedFrom: DateTimeOffset.UtcNow.AddDays(-365)), 1, 25);
+        Assert.Equal(2, wide.TotalCount);
+
+        var counts = await _deployments.GetDeploymentStatusCountsAsync(
+            new DeploymentListFilter(Search: "Filler", SearchMode: DeploymentSearchMode.Contains));
+        Assert.Equal(1, counts.Total);
+    }
+
+    /// <summary>A literal percent is not a wildcard in prefix mode.</summary>
+    [Fact]
+    public async Task Deployments_Prefix_TreatsPercentAsLiteral()
+    {
+        await SeedDeploymentsAsync();
+        var page = await _deployments.QueryDeploymentListPageAsync(new DeploymentListFilter(Search: "%"), 1, 25);
+        Assert.Equal(0, page.TotalCount);
+    }
+
+    /// <summary>Audit entity-name: prefix by default, bounded Contains on opt-in.</summary>
+    [Fact]
+    public async Task AuditLog_EntityName_PrefixByDefault_ContainsOptInWithinWindow()
+    {
+        _context.AuditLogEntries.AddRange(
+            new AuditLogEntry("a", "Create", "Template", "1", "PumpStation") { Timestamp = DateTimeOffset.UtcNow },
+            new AuditLogEntry("a", "Create", "Template", "2", "BigPump") { Timestamp = DateTimeOffset.UtcNow },
+            new AuditLogEntry("a", "Create", "Template", "3", "OldPump") { Timestamp = DateTimeOffset.UtcNow.AddDays(-90) });
+        await _context.SaveChangesAsync();
+
+        var (prefix, _) = await _audit.GetAuditLogEntriesAsync(entityName: "pump");
+        Assert.Equal("PumpStation", Assert.Single(prefix).EntityName);
+
+        var (contains, _) = await _audit.GetAuditLogEntriesAsync(entityName: "Pump", entityNameContains: true);
+        Assert.Equal(new[] { "BigPump", "PumpStation" }, contains.Select(e => e.EntityName).OrderBy(n => n));
+
+        var (wide, _) = await _audit.GetAuditLogEntriesAsync(
+            entityName: "Pump", entityNameContains: true, from: DateTimeOffset.UtcNow.AddDays(-365));
+        Assert.Equal(3, wide.Count);
+    }
+}