diff --git a/.claude/skills/umb-review/SKILL.md b/.claude/skills/umb-review/SKILL.md
new file mode 100644
index 000000000000..b0af1bb13bce
--- /dev/null
+++ b/.claude/skills/umb-review/SKILL.md
@@ -0,0 +1,251 @@
+---
+name: umb-review
+description: Automated PR code review for Umbraco CMS. Analyzes changed files for intent, impact on consumers, breaking changes, architecture compliance, and code quality. Non-interactive — outputs a full structured review. Use this skill whenever the user asks to review a branch, review a PR, check their changes for issues, analyze a diff, or validate breaking change patterns — even if they don't say "review" explicitly. Does NOT apply to writing new code, fixing bugs, refactoring, explaining architecture, writing tests, or reviewing documentation content.
+argument-hint: <target-branch>
+---
+
+# PR Review - Umbraco CMS
+
+Automated, non-interactive PR code review. Analyzes changed files for intent, impact on consumers, breaking changes, architecture compliance, and code quality.
+
+**Do NOT use AskUserQuestion at any point. This skill runs fully autonomously.**
+
+## Arguments
+
+- `$ARGUMENTS` - Optional: target branch to diff against (auto-detected from PR, falls back to `origin/main`)
+
+## Instructions
+
+### 0. Verify GH CLI is Available
+
+Run `gh auth status`. If it fails, read `references/gh-cli-setup.md` and present the setup instructions to the user. Do not proceed with the review.
+
+### 1. Resolve Target Branch
+
+Determine the target branch for comparison using this priority order:
+
+1. **Explicit argument**: If `$ARGUMENTS` is provided and non-empty, use it as the target branch
+2. **PR target branch**: If no argument, run `gh pr view --json baseRefName --jq '.baseRefName'` to detect the target branch of the current branch's open PR. If a PR exists, use `origin/{baseRefName}` as the target branch.
+3. **Fallback**: If no argument and no PR found (command fails or returns empty), default to `origin/main`
+
+Store the resolved target branch for use in subsequent steps. Log which resolution method was used (e.g., "Target branch: `origin/v18/dev` (from PR #1234)").
+
+### 2. Load Review Standards
+
+#### 2a. Load coding preferences
+
+Read the coding preferences and code review scoring criteria from:
+
+- `references/coding-preferences.md` (relative to this skill file)
+
+Parse and internalize all rules, conventions, scoring categories, and severity definitions. These are your review criteria.
+
+#### 2b. Load area-specific documentation
+
+Once the changed file list is known (after step 3a), determine which areas of the codebase are touched and load the relevant documentation. Execute this sub-step between 3a and 3b. This documentation takes precedence over sibling comparison for architectural and pattern validation.
+
+**Resolution order for each changed file:**
+
+1. **Find the nearest `CLAUDE.md`** — walk up from the changed file's directory toward the repository root. The first `CLAUDE.md` found is the area guide for that file. Read it.
+2. **Read referenced docs** — if the `CLAUDE.md` references documentation files (e.g., a `docs/` directory), use the descriptions in the `CLAUDE.md` to determine which docs are relevant to the type of code being changed, and read those. If unsure, read all referenced docs — the cost of reading is low, the cost of missing a convention is high.
+3. **Follow cross-references in loaded docs** — if a loaded doc references another doc as covering a complementary or related concern, and the changed files touch that concern, read the referenced doc too. Repeat until no new relevant cross-references remain.
+4. **Check for applicable skills** — review the available skills list. If a skill exists for the type of code being changed, read the skill file to understand the expected patterns, structure, and conventions it enforces. Do NOT invoke the skill — just use it as a reference for what the correct implementation should look like.
+
+**Store all loaded documentation** for use in step 4. These docs define the authoritative patterns and conventions that the review evaluates against.
+
+### 3. Gather Changed Files
+
+#### 3a. Collect file list, stats, and diff
+
+Run these git commands (where `{target}` is the resolved target branch):
+
+```bash
+git diff {target}...HEAD --name-only --diff-filter=d   # changed files (excluding deleted)
+git diff {target}...HEAD --stat                         # line counts per file
+git log {target}...HEAD --oneline                       # commit history
+git diff {target}...HEAD                                # full diff (primary review source)
+```
+
+**If no changes found**: Output "No changes found between current branch and `{target}`. Nothing to review." and stop.
+
+#### 3b. Filter out noise files
+
+From the changed file list, classify each file as **noise** or **reviewable**.
+
+**Noise files** (skip entirely — do not read, do not review):
+
+| Pattern                                              | Reason                          |
+| ---------------------------------------------------- | ------------------------------- |
+| `*.gen.ts`, `*.gen.cs`                               | Auto-generated API client code  |
+| `*.generated.cs`, `*.Designer.cs` (in `Migrations/`) | Auto-generated models/snapshots |
+| `*/assets/lang/*.ts` (except `en.ts`)                | Non-English translation files   |
+| `*/mocks/data/*.ts`                                  | Test fixture data               |
+| `*/dist-cms/*`, `*/storybook-static/*`               | Build output                    |
+| `*/TEMP/InMemoryAuto/*`                              | Runtime-generated models        |
+| `package-lock.json`                                  | Dependency lock file            |
+| `appsettings-schema.*.json`                          | Generated JSON schema           |
+
+Log the skip list: "Skipped {N} noise files: {comma-separated list of filenames}"
+
+#### 3c. Read reviewable changed files
+
+Read the full file for every reviewable changed file.
+
+#### 3d. Track file counts
+
+Keep track of these numbers for the review output in step 7: total changed files, noise files skipped, and reviewable files read. Also record: distinct production layers touched, distinct project directories, and total lines changed — these feed step 3e.
+
+#### 3e. Assess PR complexity
+
+Follow the procedure in `references/complexity-assessment.md`. Store the triggered dimensions and suggestions for step 7.
+
+#### 3f. Classify PR scope
+
+Classify the PR to determine which review steps are relevant:
+
+| Classification  | Condition                                                                       | Effect                                                                          |
+| --------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- |
+| **Gen-only**    | All reviewable files are `gen.ts`                                               | Skip steps 5 and 6; step 4 reviews impact on other code only                    |
+| **Docs-only**   | All reviewable files are `.md`                                                  | Skip steps 5 and 6; step 4 reviews intent and readability only                  |
+| **Test-only**   | All reviewable files are in `tests/`                                            | Skip steps 5 and 6; step 4 reviews intent, code quality, and test coverage only |
+| **Config-only** | All reviewable files are `.csproj`, `.props`, `.json` config, or CI/build files | Skip step 5; step 6 checks dependency version changes only                      |
+| **Standard**    | Anything else                                                                   | No skips — run all steps                                                        |
+
+### 4. Raw Code Review
+
+Review each changed file holistically. Think like a senior developer reading a colleague's PR. Note all findings without worrying about format or severity yet.
+
+#### 4a. Read and reason about each file
+
+For each changed file, reason about: What does this code do? Is it correct? What's missing — validation, error handling, notifications, cleanup, edge cases? Could this break anything for consumers?
+
+#### 4b. Validate against documentation and patterns
+
+Use a **docs-first** approach: classify the code by what it does, check it against documented conventions, and only fall back to sibling comparison when docs don't cover the pattern.
+
+**Step 1 — Determine the correct approach from documentation, then check whether the PR matches**
+
+A PR is a proposed solution, not the source of truth. This step has two parts that must happen in order — do not start part B until part A is complete.
+
+**Part A — Before validating/judging the implementation**, determine what the correct approach is for each new class or file based on what it does. Use the documentation loaded in step 2b to identify the expected base classes, patterns, and conventions. Write down the expected approach. Classify based on what the code does, not based on what neighboring files look like.
+
+**Part B — Now compare the PR's implementation** against the expected approach from Part A. If it deviates from the documented approach, flag it. If the documentation specifies reference examples, read those examples to verify the implementation matches.
+
+**Pattern match is the leading finding.** If the documentation defines a pattern that fits what the code does, the first and most important finding is whether the code follows that pattern.
+
+**Step 2 — Fall back to sibling comparison**
+
+If the documentation does not cover the specific pattern, or for cross-cutting concerns not addressed in docs, fall back to sibling comparison:
+
+1. **New method on existing class/interface**: Grep for the most similar existing method on the same class using `-A 80` to capture the full method body (e.g., `UpdateCurrentUserAsync` → grep for `UpdateAsync` in the same file with `-A 80`). Compare line by line for missing cross-cutting concerns: notifications/events, validation, scoping, authorization, error handling, audit logging.
+2. **New TS class**: Grep for siblings by base class (`extends {BaseClass}`) or by interface (`implements {Interface}`) or by name suffix (e.g., `CurrentUserController` → grep for `UserController`). Compare for missing concerns.
+3. **New CS class**: Grep for siblings by base class (`class {ClassName} : {BaseClass}`) or by interface (`class {ClassName} : {Interface}`) or by name suffix (e.g., `ManagementApiComposer` → grep for `ApiComposer`). Compare for missing concerns.
+
+**Important:** Sibling comparison validates cross-cutting concerns, but it must not override documented conventions. If a sibling deviates from documented patterns, that sibling is wrong — do not copy its deviation.
+
+Store your raw findings — they feed into step 7.
+
+### 5. Impact Analysis
+
+**Skip this step if PR scope is docs-only, test-only, or config-only.**
+
+Follow the procedure in `references/impact-analysis.md`.
+
+### 6. Breaking Changes Check
+
+**Skip this step if PR scope is docs-only or test-only. If config-only, only check for dependency version changes that could break consumers.**
+
+Follow the procedure in `references/breaking-changes.md`.
+
+### 7. Consolidate and Output Review
+
+Merge findings from step 4 (raw review), step 5 (impact analysis), and step 6 (breaking changes). For each finding, assign severity (Critical/Important/Suggestion) and verify it relates to changed code — not pre-existing issues. Before outputting, drop any finding about whitespace, blank lines, formatting, or comment wording. Then present the review in this exact format:
+
+```markdown
+## PR Review
+
+**Target:** `{target_branch}` · **Based on commit:** `{head_sha}`
+[If any skipped files, append: · **Skipped:** {skipped} files out of {total} total]
+[If step 3f classification is not "Standard", append: · **Classified as:** {classification}]
+
+[1–2 sentences: what this PR accomplishes , keep it as short as possible, only highlight the primary essence.]
+
+- **Modified public API:** {changed existing interfaces/types/classes/methods}
+  [Omit bullet if none]
+- **Affected implementations (outside this PR):** {interfaces/types/classes/methods using modified public API}
+  [Omit bullet if none]
+- **Breaking changes:** {violations with specifics}
+  [Omit bullet if none]
+- **Other changes:** {changes not listed above that an Umbraco user, plugin developer, or API consumer would notice — e.g., behavior changes, default value changes, error message changes, new configuration options, removed functionality. Exclude internal renames, formatting, and private implementation details.}
+  [Omit bullet if none]
+
+[If step 3e triggered any dimensions, insert this block. Omit entirely if nothing triggered:]
+
+> [!NOTE]
+> **Complexity advisory** — This PR may benefit from splitting.
+>
+> - **{Dimension}:** {Explanation and concrete split suggestion from step 3e}
+>   [one bullet per triggered dimension]
+>
+> _This is an observation, not a blocker. The full review follows below._
+
+---
+
+### Critical
+
+[Must fix before merge — security vulnerabilities, data loss, broken functionality, breaking changes without proper patterns]
+
+- **`{file}:{line}`**: {problem} → {fix}
+
+[Omit section if none]
+
+### Important
+
+[Should fix — performance issues, missing tests, architectural violations, pattern misuse]
+
+- **`{file}:{line}`**: {observation} → {suggestion}
+
+[Omit section if none]
+
+### Suggestions
+
+[Nice to have — readability, minor refactoring, alternative approaches]
+
+- **`{file}:{line}`**: {detail}
+
+[Omit section if none]
+
+---
+
+[One of:]
+
+## Approved
+
+This looks good to be merged as-is, but please do a manual sanity check and testing before merging.
+
+## Approved with Suggestions for improvement
+
+Good to go, but please carefully consider the importance of the suggestions.
+
+## Request Changes
+
+Critical and important issues must be addressed first.
+
+## Needs re-work
+
+This is in such a bad state that the feedback of this review is not sufficient to guide improvements, the PR cannot be approved.
+```
+
+**Guidelines for the review output:**
+
+— When reporting information, be extremely concise and sacrifice grammar for sake of concision.
+
+- Only review code that was changed in the diff — pre-existing issues are out of scope. Focus on what compilers and linters cannot catch: behavioral side-effects (e.g., a changed default alters runtime behavior for consumers), architectural violations (e.g., a new dependency breaks layering), breaking changes for external consumers of the public API, and security implications. Leave type errors, missing imports, and broken references to CI.
+- Be specific — always reference file and line number
+- Explain WHY something is an issue, not just WHAT, but avoid stating the obvious.
+- For complex matters, provide concrete fix suggestions, including code snippets when helpful
+- Keep it constructive — the goal is to help, not gatekeep
+- Don't repeat the same finding for every occurrence — mention it once and note "same pattern in {other files}"
+- Focus on substantive issues only. Do NOT flag purely cosmetic or stylistic concerns. Specifically, never flag: code formatting or whitespace, comment grammar or wording, redundant-but-harmless syntax (e.g., optional chaining after a truthiness check), code duplication that doesn't cause bugs, or HTML template cosmetics. The only exception is when a stylistic issue has a concrete impact on performance or rendering. Note: missing JSDoc/documentation on public or exported APIs is a substantive finding (per coding preferences), not a cosmetic one — flag it as a Suggestion.
+- For breaking changes, reference the specific pattern from the CLAUDE.md that should be applied
+- Do not suggest changes that would themselves introduce breaking changes. If a suggestion would alter public API surface (e.g., changing return types, renaming public members), it is not appropriate for a PR targeting `main` within a major version. Only suggest non-breaking alternatives.
diff --git a/.claude/skills/umb-review/evals/evals.json b/.claude/skills/umb-review/evals/evals.json
new file mode 100644
index 000000000000..538bb548eb99
--- /dev/null
+++ b/.claude/skills/umb-review/evals/evals.json
@@ -0,0 +1,97 @@
+{
+  "skill_name": "umb-review",
+  "evals": [
+    {
+      "id": 0,
+      "name": "pr-22214-large-frontend-refactor",
+      "prompt": "Review the changes in PR #22214 (branch origin/pr/22214 targeting main). This is a large frontend refactor migrating create entity actions to use entityCreateOptionAction extensions, with deprecations.",
+      "expected_output": "A structured review that identifies frontend deprecation patterns, flags the large PR complexity, handles 75+ files correctly, checks for breaking changes in exported components, and produces the correct output format.",
+      "pr_number": 22214,
+      "pr_branch": "origin/pr/22214",
+      "base_branch": "origin/main",
+      "files": [],
+      "assertions": [
+        {"id": "deprecation-patterns-noted", "text": "Review identifies deprecation patterns (@deprecated, UmbDeprecation)"},
+        {"id": "frontend-breaking-change-awareness", "text": "Checks frontend-specific breaking changes (exports, custom elements) not just backend"},
+        {"id": "file-references-present", "text": "Findings reference specific files with line numbers"},
+        {"id": "no-false-critical-on-deprecations", "text": "Properly deprecated code is NOT flagged as Critical breaking change"},
+        {"id": "no-stylistic-nitpicks", "text": "Review does not flag purely cosmetic/stylistic issues (formatting, whitespace, naming conventions, comment grammar, code style preferences) unless they affect performance or rendering. Missing JSDoc on new public APIs is NOT a stylistic issue — it is a legitimate finding."},
+        {"id": "manifest-alias-rename-detected", "text": "Alias renames (CreateOptions → Create) flagged as Critical breaking change"},
+        {"id": "non-exported-deletions-dismissed", "text": "Deleted action classes NOT flagged as breaking (verified against package.json exports)"},
+        {"id": "noise-files-filtered", "text": "Does not review noise files (generated files, lock files, etc.)"},
+        {"id": "complexity-advisory-triggers", "text": "Review includes a complexity/split advisory for the large 75+ file scope"}
+      ]
+    },
+    {
+      "id": 1,
+      "name": "pr-21672-small-frontend-bugfix",
+      "prompt": "Review the changes in PR #21672 (branch origin/pr/21672 targeting main). This is a small 4-file frontend bugfix implementing tab validation badges in the block editor.",
+      "expected_output": "A clean review that correctly identifies this as a small focused bugfix, avoids false positives, and either approves or approves with minor suggestions.",
+      "pr_number": 21672,
+      "pr_branch": "origin/pr/21672",
+      "base_branch": "origin/main",
+      "files": [],
+      "assertions": [
+        {"id": "complexity-advisory-absent", "text": "Review does NOT include a complexity/split advisory"},
+        {"id": "no-false-breaking-changes", "text": "Review does not flag breaking changes"},
+        {"id": "proportionate-verdict", "text": "Verdict is 'Request Changes'"},
+        {"id": "concise-review", "text": "Review output is under 200 lines"},
+        {"id": "no-stylistic-nitpicks", "text": "Review does not flag purely cosmetic/stylistic issues (formatting, whitespace, naming conventions, comment grammar, code style preferences) unless they affect performance or rendering. Missing JSDoc on new public APIs is NOT a stylistic issue — it is a legitimate finding."}
+      ]
+    },
+    {
+      "id": 2,
+      "name": "pr-22217-small-backend-webhook",
+      "prompt": "Review the changes in PR #22217 (branch origin/pr/22217 targeting v18/dev). This is a tiny 3-file backend change to the default webhook payload type.",
+      "expected_output": "A concise review that correctly resolves v18/dev as target branch, handles the small change proportionately, and considers the behavioral impact of changing a default value.",
+      "pr_number": 22217,
+      "pr_branch": "origin/pr/22217",
+      "base_branch": "origin/v18/dev",
+      "files": [],
+      "assertions": [
+        {"id": "correct-target-branch", "text": "Review references 'v18/dev' as the target branch (not 'main')"},
+        {"id": "default-value-change-noted", "text": "Review discusses the behavioral impact of changing the default payload type"},
+        {"id": "proportionate-review", "text": "Review output is under 150 lines"},
+        {"id": "no-stylistic-nitpicks", "text": "Review does not flag purely cosmetic/stylistic issues (formatting, whitespace, naming conventions, comment grammar, code style preferences) unless they affect performance or rendering. Missing JSDoc on new public APIs is NOT a stylistic issue — it is a legitimate finding."},
+        {"id": "ignores-preexisting-issues", "text": "Does NOT flag the ~30 builder extension methods with Legacy defaults (pre-existing, not changed in the PR)"},
+        {"id": "side-effect-detection", "text": "Flags stale WebhookSettings.cs docs as a side-effect of the constant value change"},
+        {"id": "consumer-identification", "text": "Identifies affected consumers outside the PR (WebhookSettings, UmbracoBuilder, or WebhookEventCollectionBuilderExtensions)"}
+      ]
+    },
+    {
+      "id": 3,
+      "name": "pr-22268-frontend-feature-workspace-modal",
+      "prompt": "Review the changes in PR #22268 (branch origin/pr/22268 targeting main). This is a 29-file frontend feature adding a current user workspace modal.",
+      "expected_output": "A review of a medium-sized new feature PR. Should assess the new code for architectural compliance, check for breaking changes (new exports, custom elements), and evaluate code quality without flagging pre-existing issues.",
+      "pr_number": 22268,
+      "pr_branch": "origin/pr/22268",
+      "base_branch": "origin/main",
+      "files": [],
+      "assertions": [
+        {"id": "complexity-advisory-triggers", "text": "Review includes a complexity/split advisory (3 layers: Core, API, Frontend across 27+ files)"},
+        {"id": "breaking-changes-on-interface-additions", "text": "Flags new interface methods without default implementations as breaking changes (Pattern 3)"},
+        {"id": "no-stylistic-nitpicks", "text": "Review does not flag purely cosmetic/stylistic issues unless they affect performance or rendering. Missing JSDoc on new public APIs is NOT a stylistic issue — it is a legitimate finding."},
+        {"id": "diff-scoped", "text": "All findings reference code that was changed in the diff, not pre-existing issues"},
+        {"id": "new-feature-assessed", "text": "Review assesses the new feature's architecture, patterns, or integration approach — not just absence of bugs"},
+        {"id": "no-false-notification-finding", "text": "Review does NOT flag UpdateCurrentUserAsync as missing UserSavingNotification/UserSavedNotification — the sibling UpdateAsync also does not publish these notifications, so flagging their absence would be a false positive"}
+      ]
+    },
+    {
+      "id": 4,
+      "name": "pr-22215-frontend-architecture-violation",
+      "prompt": "Review the changes in PR #22215 (branch origin/pr/22215 targeting main). This is a 2-file frontend feature adding user management to the user group workspace.",
+      "expected_output": "A review that catches the architecture violation: the workspace context directly imports and calls UserService and UserGroupService (generated API clients) instead of going through a repository. In the Umbraco backoffice, workspace contexts access data via repositories, not by calling API services directly. The review should flag this as a significant architecture issue and request changes.",
+      "pr_number": 22215,
+      "pr_branch": "origin/pr/22215",
+      "base_branch": "origin/main",
+      "files": [],
+      "assertions": [
+        {"id": "service-bypass-detected", "text": "Review flags that the workspace context directly imports/calls UserService or UserGroupService instead of using a repository"},
+        {"id": "repository-pattern-recommended", "text": "Review recommends using the repository pattern (going through a repository/data-source layer) rather than calling API services directly from the workspace context"},
+        {"id": "verdict-request-changes", "text": "Verdict is 'Request Changes' (the architecture violation warrants requesting changes, not just approving with suggestions)"},
+        {"id": "no-stylistic-nitpicks", "text": "Review does not flag purely cosmetic/stylistic issues (formatting, whitespace, naming conventions, comment grammar, code style preferences) unless they affect performance or rendering. Missing JSDoc on new public APIs is NOT a stylistic issue — it is a legitimate finding."},
+        {"id": "no-false-breaking-changes", "text": "Review does not flag breaking changes (this PR only adds new code, no public API is removed or modified)"}
+      ]
+    }
+  ]
+}
diff --git a/.claude/skills/umb-review/references/breaking-changes.md b/.claude/skills/umb-review/references/breaking-changes.md
new file mode 100644
index 000000000000..052867d8598c
--- /dev/null
+++ b/.claude/skills/umb-review/references/breaking-changes.md
@@ -0,0 +1,249 @@
+# Breaking Changes Reference
+
+This document describes how to detect and validate breaking changes during PR review. It covers both backend (.NET) and frontend (TypeScript/Lit) patterns.
+
+---
+
+## Version Detection
+
+**Always read `version.json`** at the repository root to determine the current major version. This drives the obsolete removal target calculation:
+
+- Current major version: read from `version.json` → `version` field (e.g., `"17.4.0-rc"` → major version `17`)
+- Obsolete removal target: `current + 2` (e.g., if current is 17, removal is scheduled for Umbraco 19)
+- Format: `[Obsolete("... Scheduled for removal in Umbraco {current+2}.")]`
+
+---
+
+## Backend (.NET) Breaking Changes
+
+### What Constitutes a Breaking Change
+
+Any of these on a `public` or `protected` member:
+
+- Removing or renaming a class, interface, struct, record, or enum
+- Removing or renaming a method, property, or field
+- Changing a method signature (parameters, return type)
+- Adding required parameters to an existing method
+- Adding methods to a public interface (without default implementation)
+- Changing a constructor signature on a public class
+- Removing or changing enum values
+- Changing type hierarchy (base class, implemented interfaces)
+
+### Pattern 1: Obsolete Constructor + StaticServiceProvider
+
+When a public class needs new dependencies, the existing constructor must be preserved.
+
+**Correct pattern:**
+
+```csharp
+[Obsolete("Please use the constructor with all parameters. Scheduled for removal in Umbraco 19.")]
+public MyService(IDependencyA depA)
+    : this(
+        depA,
+        StaticServiceProvider.Instance.GetRequiredService<IDependencyB>())
+{
+}
+
+public MyService(IDependencyA depA, IDependencyB depB)
+{
+    _depA = depA;
+    _depB = depB;
+}
+```
+
+**Validation checklist:**
+
+- [ ] Old constructor has `[Obsolete]` attribute with correct removal version
+- [ ] Old constructor calls new constructor via `: this(...)`
+- [ ] `StaticServiceProvider.Instance.GetRequiredService<T>()` used for new params only
+- [ ] DI registration uses the NEW constructor (old is for external consumers only)
+- [ ] Removal version is `{current_major + 2}`
+
+**Common mistakes to flag:**
+
+- Removing the old constructor entirely (breaking change!)
+- Old constructor NOT calling new constructor (code duplication)
+- Wrong removal version in `[Obsolete]`
+- Missing `StaticServiceProvider` resolution for new dependencies
+- DI registration still using the old constructor
+
+### Pattern 2: Obsolete Method + New Overload
+
+When a method signature needs to change, add the new overload and obsolete the old.
+
+**Correct pattern:**
+
+```csharp
+[Obsolete("Use the overload taking all parameters. Scheduled for removal in Umbraco 19.")]
+public void DoThing(string name)
+    => DoThing(name, extraParam: null);
+
+public void DoThing(string name, string? extraParam)
+{
+    // Real implementation here
+}
+```
+
+**Validation checklist:**
+
+- [ ] Old method has `[Obsolete]` attribute with correct removal version
+- [ ] Old method calls new method, providing defaults for new parameters
+- [ ] All internal callers updated to use the new method
+- [ ] No internal code references the obsolete method (except the delegation)
+
+### Pattern 3: Default Interface Implementation
+
+When adding methods to a public interface, provide a default implementation.
+
+**Correct pattern:**
+
+```csharp
+public interface IMyService
+{
+    void ExistingMethod();
+
+    // New method with default implementation
+    void NewMethod(string param)
+        => ExistingMethod(); // delegate to existing if possible
+}
+```
+
+**Strategies for defaults (in order of preference):**
+
+1. Use existing interface methods to satisfy the contract
+2. Return a sensible default (empty collection, null, etc.)
+3. Throw `NotImplementedException` if no reasonable default exists
+
+**Validation checklist:**
+
+- [ ] New interface method has a default implementation
+- [ ] TODO comment present: `// TODO (V{next-major}): Remove the default implementation when {obsolete method} is removed.`
+- [ ] Default implementation is functionally correct (even if not optimal)
+- [ ] If `StaticServiceProvider` is used in default impl, noted as temporary
+
+### Obsolete Attribute Validation
+
+For any `[Obsolete]` attribute found in changed code:
+
+1. **Format**: Must contain `"Scheduled for removal in Umbraco {version}."`
+2. **Version**: Must be `current_major + 2` (read from `version.json`)
+3. **Pragma**: Where obsolete members must call each other, `#pragma warning disable CS0618` / `#pragma warning restore CS0618` must be present
+
+### Internal Caller Check
+
+After finding obsolete patterns, verify:
+
+- Search the codebase for usages of the obsolete member
+- **No internal code** (inside `src/`) should reference obsolete members
+- Only the obsolete member's own delegation (calling the new version) is acceptable
+- External consumers (outside the repo) get the deprecation period to migrate
+
+---
+
+## Frontend (TypeScript/Lit) Breaking Changes
+
+The backoffice is published as `@umbraco-cms/backoffice` with 140+ named exports. Plugin developers depend on this public API surface.
+
+**Critical frontend rule (does not apply to backend .NET where `public`/`protected` visibility determines the API surface): only symbols reachable through the `package.json` `exports` field are public API.** Anything not exported — whether classes, functions, constants, types, or entire files — is an internal implementation detail, even if other internal code imports it. Removing or changing unexported frontend symbols is not a breaking change. Before flagging a frontend deletion or rename as breaking, verify the symbol is reachable via `package.json` exports. If it is not, do not flag it.
+
+### Custom Elements (Web Components)
+
+**Breaking changes:**
+
+- Renaming or removing a registered custom element tag (`umb-*`)
+- Removing elements from `HTMLElementTagNameMap`
+- Removing or changing `@property()` decorated fields on exported components
+- Removing event emissions (checked via `this.dispatchEvent`)
+- Removing CSS custom properties (`@cssprop` in JSDoc)
+- Removing CSS parts (`@csspart` in JSDoc)
+
+**How to detect:**
+
+- Check diff for removed `@customElement('umb-...')` decorators
+- Check diff for removed `@property()` fields on exported components
+- Check diff for removed entries in `HTMLElementTagNameMap` declarations
+
+### Exported Types/Interfaces
+
+**Breaking changes:**
+
+- Removing exports from `package.json` `exports` field
+- Changing the shape of exported interfaces (removing properties, changing types)
+- Renaming exported types (consumers import by name)
+- Removing union type members
+- Changing generic type parameter constraints
+
+**How to detect:**
+
+- Check if `package.json` `exports` field is modified
+- Check diff for removed `export` statements
+- Check diff for changed interface/type shapes
+
+### Manifest/Extension System
+
+**Breaking changes:**
+
+- Renaming a manifest `alias` value — plugin developers reference aliases by string in conditions, overwrites, and extension registry lookups. Alias renames are not caught by the compiler since they are string-based. A renamed alias silently breaks any plugin that references the old string.
+- Removing support for a manifest `type` that plugins use
+- Changing manifest `alias` resolution or validation
+- Removing or renaming manifest `kind` types
+- Changing extension bundle structure
+
+**How to detect:**
+
+- **Alias renames**: Compare `alias:` values in manifest files before and after. Changed alias strings are Critical — the old alias should be preserved as a deprecated entry.
+- Search for changes to manifest type definitions
+- Check for removed or renamed manifest kinds
+
+### Context API
+
+**Breaking changes:**
+
+- Removing context tokens from exports
+- Changing the shape of data provided by a context
+- Removing context provider/consumer mechanisms
+
+**How to detect:**
+
+- Check for removed context token exports
+- Check for changes to context provider classes
+
+### Controllers/Lifecycle
+
+**Breaking changes:**
+
+- Changing controller base class inheritance requirements
+- Removing controller lifecycle hooks
+- Breaking cleanup mechanisms in `disconnectedCallback()`
+
+### Observable/State
+
+**Breaking changes:**
+
+- Removing observable properties from the public API
+- Changing observable emission patterns
+
+### npm Publishing
+
+**Breaking changes:**
+
+- Changing version constraints that exclude previously-supported versions
+- Adding incompatible peer dependency constraints
+
+**How to detect:**
+
+- Check if `package.json` `peerDependencies` or `dependencies` changed
+- Verify version ranges are not narrowed
+
+---
+
+## Reporting Breaking Changes
+
+When a breaking change is detected, report:
+
+1. **What**: The specific change and which public symbol is affected
+2. **Pattern**: Which mitigation pattern should be applied (Pattern 1, 2, or 3 for backend)
+3. **Severity**: Critical (no mitigation present) or Important (mitigation present but incorrect)
+4. **Fix**: Concrete code suggestion showing the correct pattern
+
+If no breaking changes are detected, state: "No breaking changes detected."
diff --git a/.claude/skills/umb-review/references/coding-preferences.md b/.claude/skills/umb-review/references/coding-preferences.md
new file mode 100644
index 000000000000..6ac861aa6659
--- /dev/null
+++ b/.claude/skills/umb-review/references/coding-preferences.md
@@ -0,0 +1,168 @@
+# Coding Preferences & Review Criteria
+
+These are the coding preferences and code review standards used by the review skill. They define what the review evaluates against.
+
+---
+
+## Testing
+
+- **Always create blackbox tests** for new/changed code
+- Choose the appropriate test level:
+  - **Unit tests** for isolated logic
+  - **Integration tests** for application services/use cases
+  - **E2E tests** for API endpoints
+
+### Test Class Naming
+
+- Test classes must be postfixed with `Tests` (e.g., `OrderServiceTests`)
+- One test class per class under test
+
+### Test Method Naming
+
+**C# tests**: Use the `Can_`/`Cannot_` pattern with PascalCase underscore-separated words:
+
+- `Can_Schedule_Publish_Invariant`
+- `Cannot_Delete_Non_Existing`
+- `Can_Schedule_Publish_Single_Culture`
+
+Large test classes are split into partial files by method: `ContentServiceTests.Delete.cs`, `ContentServiceTests.Publish.cs`.
+
+**TypeScript tests**: Use BDD-style `it()` with natural language descriptions:
+
+- `it('should not allow the returned value to be lower than min')`
+- `it('converts string to camelCase')`
+
+### Unit Tests
+
+- Optional, but must be blackbox tests so refactoring does not break tests
+
+### Integration Tests
+
+- Every use case / application service must have integration tests
+- Tests run against real database (containerized or similar)
+- Test the full flow from application layer through infrastructure
+
+### E2E Tests
+
+- Every API endpoint must have E2E tests
+- Test realistic scenarios including error cases
+
+---
+
+## Trade-offs
+
+When making decisions, prioritize:
+
+- **Readability** over cleverness
+- **Flexibility** over rigidity
+- Explain trade-offs when deviating from these defaults
+
+---
+
+## Breaking Changes
+
+- Communicate breaking changes at the **OpenAPI/openapi.json level**
+- Clearly document what changed and the migration path
+
+---
+
+## Documentation
+
+- **Document all public or exported types** (classes, interfaces, types, methods, properties)
+- Keep documentation in sync with code changes
+- Add **JS Docs** on all public frontend APIs (classes, methods, properties)
+- Focus on "why" and usage, not restating the obvious
+
+---
+
+## Dependencies
+
+- Use what's available in the codebase, unless there is no good choice
+- **Flag new dependencies** for review — new packages should be justified
+- Prefer well-maintained, widely-used packages
+
+---
+
+## Error Messages & Logging
+
+- **User-facing errors**: Clear, friendly, actionable
+- **Log messages**: Technical, detailed, with context
+- Include correlation IDs and relevant data in logs
+
+---
+
+## Security
+
+- **Always check for security issues** using OWASP Top 10 as baseline
+- Flag potential vulnerabilities immediately
+- Suggest secure alternatives when spotting risky patterns
+- Apply principle of least privilege
+
+---
+
+## Immutability
+
+- Prefer **immutability** by default
+- Allow internal properties to be mutated, as long as they are not direct references coming from the outside
+
+---
+
+## Nullability
+
+- **TypeScript / JavaScript**
+  - Prefer `undefined` for optional/omitted values (e.g., optional parameters, props, and fields)
+  - Use `null` only when the domain model explicitly encodes "no value" or "not set" (e.g., `string | null` from APIs/DB), and be consistent with existing types
+  - Avoid mixing `null` and `undefined` for the same concept within the same model or API surface
+  
+- **C#**  
+  - use nullable types (e.g., `string?`, `int?`) where absence is valid
+  - Prefer domain modeling (value objects, options/results, empty collections) over `null` where appropriate, but respect existing conventions in the codebase
+
+---
+
+## C# Specific
+
+- use Notification pattern (not C# events), Composer pattern (DI registration), Scoping with `Complete()`, Attempt pattern for operation results.
+
+---
+
+## Architecture
+
+- Follow **Clean Architecture** principles
+- **Fail-fast** principle: detect and report errors as early as possible
+- Within the established layered architecture (Core/Infrastructure/Web/API), organize code by feature inside each layer where practical, while preserving dependency direction
+- One class per file
+- Avoid N+1 queries
+- Profile before optimizing non-critical paths
+
+### Type Hierarchy Consistency
+
+When parallel model types have inconsistent relationships to a shared base type:
+
+**TypeScript**: manipulations via `Omit`, `Pick`, intersection overrides, or workarounds like `as unknown as` / double-casts to bridge type mismatches.
+
+**C#**: hiding base members with `new` to change types, explicit interface implementations to mask mismatches, or downcasting base return types in derived classes.
+
+- **Do NOT suggest** the PR code should deviate from its base type to match a sibling that already deviates. Copying the deviation spreads the problem.
+- **Do flag** the architectural inconsistency: parallel models should share a compatible base contract. The model that manipulates or deviates from the base type is the one that needs attention — not the one that extends it correctly.
+- **Frame the suggestion** as: "These related models have inconsistent type hierarchies. `{deviating type}` manipulates the base contract of `{base type}`, which forces shared consumers like `{shared utility}` to require a shape that conforming subtypes can't satisfy."
+
+---
+
+## Code Style
+
+- Follow standard naming conventions for the language (C# or JS/TS)
+- Keep components small and focused on a single responsibility
+- Prefer early returns
+- Small functions
+- No nested ternaries
+
+---
+
+## Severity Levels
+
+| Severity | Meaning |
+|----------|---------|
+| **Critical** | Must fix before merge — security vulnerabilities, data loss risks, broken functionality |
+| **Important** | Should fix — performance issues, missing tests, architectural violations |
+| **Suggestion** | Nice to have — readability, minor refactoring, alternative approaches |
diff --git a/.claude/skills/umb-review/references/complexity-assessment.md b/.claude/skills/umb-review/references/complexity-assessment.md
new file mode 100644
index 000000000000..14d16623a2ea
--- /dev/null
+++ b/.claude/skills/umb-review/references/complexity-assessment.md
@@ -0,0 +1,33 @@
+# PR Complexity Assessment
+
+Evaluate whether the PR's scope suggests it should be split. This assessment is **informational only** — it never blocks or shortens the review.
+
+## Always check: Formatting mixed with logic
+
+This check applies to every PR regardless of size or scope.
+
+Run both commands and compare per-file line counts:
+```bash
+git diff {target}...HEAD --stat
+git diff {target}...HEAD --stat --ignore-all-space
+```
+
+For any file where the whitespace-ignored diff is less than **half** the full diff size (and the full diff is over 50 lines), that file has significant formatting changes mixed with logic. Flag it with a split suggestion: "File(s) {list} contain significant formatting changes mixed with logic. Consider a separate formatting-only commit or PR to keep the functional diff reviewable."
+
+## Multi-project scope check
+
+Skip this section entirely if ALL production files reside in a single project directory or if the PR is docs-only, test-only, dependency-bump-only, or rename-only.
+
+Otherwise, flag any dimension that applies:
+
+| Dimension | Condition | Suggestion |
+|---|---|---|
+| **Size** | 30+ files OR 1500+ lines, spanning 2+ projects | "If changes in {projectA} and {projectB} are independently functional, they could be separate PRs." |
+| **Layer spread** | 3+ layers touched (Core/Infrastructure/Web/API/Frontend), 10+ files | "Consider splitting by layer — e.g., Core+Infrastructure first, then API/Frontend consumers." |
+| **Mixed intent** | 2+ intent categories (new feature, bugfix, refactor, dependency update) with 15+ files or 3+ projects | "Consider extracting the {secondary intent} into a separate PR." |
+
+Intent categories — detect from diff characteristics, not commit messages:
+- **New feature**: new files or new `public`/`export` declarations
+- **Bug fix**: small targeted edits, no new files (don't co-flag with new feature)
+- **Refactor**: file renames, symbols moved but logic unchanged
+- **Dependency update**: changes to `.csproj`, `Directory.Packages.props`, `package.json`
diff --git a/.claude/skills/umb-review/references/gh-cli-setup.md b/.claude/skills/umb-review/references/gh-cli-setup.md
new file mode 100644
index 000000000000..6d788d550fac
--- /dev/null
+++ b/.claude/skills/umb-review/references/gh-cli-setup.md
@@ -0,0 +1,23 @@
+# GH CLI Setup Instructions
+
+The GitHub CLI (`gh`) is required for this review skill to detect PR target branches.
+
+## Installation
+
+Install via Homebrew:
+
+```
+brew install gh
+```
+
+Or see https://cli.github.com/ for other installation methods.
+
+## Authentication
+
+After installing, authorize by running this in the terminal (use the `!` prefix in Claude Code):
+
+```
+! gh auth login
+```
+
+Follow the prompts to authenticate with your GitHub account.
diff --git a/.claude/skills/umb-review/references/impact-analysis.md b/.claude/skills/umb-review/references/impact-analysis.md
new file mode 100644
index 000000000000..e40fa03c08ea
--- /dev/null
+++ b/.claude/skills/umb-review/references/impact-analysis.md
@@ -0,0 +1,153 @@
+# Impact Analysis Reference
+
+This document describes how to perform impact analysis during PR review. The goal is to look beyond the diff to understand how changes affect consumers in other parts of the codebase.
+
+---
+
+## 1. Extract Changed Public Symbols
+
+Scan the diff output for changes to public API surface:
+
+### Backend (.NET)
+
+Look for added, modified, or removed lines containing:
+
+- `public class`, `public abstract class`, `public sealed class`
+- `public interface`
+- `public record`, `public struct`, `public enum`
+- `public` or `protected` methods, properties, fields
+- `public static` members
+- Constructor signatures on public types
+
+### Frontend (TypeScript/Lit)
+
+Look for changes to:
+
+- `export class`, `export interface`, `export type`, `export enum`
+- `export function`, `export const`
+- `@property()` decorated fields on exported components
+- `@customElement()` registrations
+- Entries in `package.json` `exports` field
+
+Collect a list of all changed public symbol names (type names, method names, property names).
+
+---
+
+## 2. Search for Consumers
+
+For each changed public symbol, search the `src/` directory for usages **outside the changed file itself**.
+
+### Grep Strategy
+
+Use the Grep tool with these settings:
+
+```
+pattern: {symbol name}
+path: src/
+output_mode: files_with_matches
+head_limit: 20
+```
+
+Use `head_limit: 20` to avoid overwhelming results — if there are more than 20 consumers, note "20+ consumers found" and list the first 20.
+
+### What to Search For
+
+For each changed type/method, search for:
+
+- **Type references**: class name, interface name (e.g., `IContentService`)
+- **Method calls**: method name in context (e.g., `\.GetById\(` for a method rename)
+- **Constructor usage**: `new TypeName(`
+- **DI registrations**: `.AddSingleton<IType, Type>`, `.AddScoped<`, `.AddTransient<`
+- **Notification handlers**: if a notification type changed, search for `INotificationHandler<NotificationTypeName>` and `INotificationAsyncHandler<NotificationTypeName>`
+- **Interface implementations**: if an interface changed, search for `: IInterfaceName` or `IInterfaceName,`
+
+### Excluding the Changed File
+
+When reporting consumers, exclude files that are part of the PR's changes (they're already being reviewed). The interesting consumers are those **outside** the PR that may be affected.
+
+---
+
+## 3. Check Dependency Flow Direction
+
+The Umbraco architecture enforces strict unidirectional dependencies:
+
+```
+Api.Management / Api.Delivery (depend on Api.Common)
+  ↓
+Api.Common (depends on Web.Common)
+  ↓
+Web.Common (depends on Infrastructure)
+  ↓
+Infrastructure (depends on Core)
+  ↓
+Core (no dependencies)
+```
+
+### Layer Mapping
+
+Map each changed file to its architectural layer:
+
+| Path prefix | Layer |
+|---|---|
+| `src/Umbraco.Core/` | Core |
+| `src/Umbraco.Infrastructure/` | Infrastructure |
+| `src/Umbraco.PublishedCache.*` | Infrastructure |
+| `src/Umbraco.Examine.Lucene/` | Infrastructure |
+| `src/Umbraco.Cms.Persistence.*` | Infrastructure |
+| `src/Umbraco.Web.Common/` | Web |
+| `src/Umbraco.Web.UI/` | Web (Application) |
+| `src/Umbraco.Web.Website/` | Web |
+| `src/Umbraco.Cms.Api.Common/` | API |
+| `src/Umbraco.Cms.Api.Management/` | API |
+| `src/Umbraco.Cms.Api.Delivery/` | API |
+| `src/Umbraco.Web.UI.Client/` | Frontend |
+| `tests/` | Test |
+
+### Violation Detection
+
+Flag if a change introduces:
+
+- **Core depending on Infrastructure**: Core file importing/referencing Infrastructure types
+- **Core depending on Web/API**: Core file importing/referencing Web or API types
+- **Infrastructure depending on Web/API**: Infrastructure file importing Web or API types
+- **Cross-API dependencies**: Management API depending on Delivery API or vice versa
+
+### How to Check
+
+1. For each changed file, identify its layer
+2. Read the file's `using` statements (C#) or `import` statements (TS)
+3. Check if any imports reference a higher layer
+4. Also check if new parameters or return types come from higher layers
+
+---
+
+## 4. Flag Cross-Project Risks
+
+### High-Risk Patterns
+
+These changes have high ripple potential:
+
+- **Interface changes in Core** — all implementations in Infrastructure must be updated
+- **Notification type changes** — all handlers across the codebase are affected
+- **Base class changes** — all derived classes are affected
+- **Composer changes** — can affect DI container and runtime behavior globally
+- **Shared model/DTO changes** — can affect serialization, API contracts, and consumers
+
+### What to Report
+
+For each cross-project risk found, report:
+
+1. **What changed**: The specific symbol and how it changed
+2. **Who is affected**: List of consuming files/projects found via Grep
+3. **Risk level**: Whether the consumers will break (compile error), behave differently (runtime), or are unaffected
+4. **Recommendation**: Whether the PR should include updates to affected consumers
+
+---
+
+## 5. Performance Notes
+
+- Use `head_limit: 20` on all Grep searches to cap results
+- Only search for symbols that actually changed (not every symbol in the file)
+- For very common type names (e.g., `IScope`, `ILogger`), consider adding more context to the search pattern to reduce false positives
+- Skip impact analysis for test files — they don't have external consumers
+- Skip impact analysis for private/internal members — they can't have external consumers
diff --git a/CLAUDE.md b/CLAUDE.md
index 05ee07ed7dae..33d837f6a60d 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -423,64 +423,19 @@ APIs use `Asp.Versioning.Mvc`:
 - Delivery API: `/umbraco/delivery/api/v{version}/*`
 - OpenAPI/Swagger docs per version
 
-### Backoffice npm Package Structure
+### Updating `OpenApi.json` (Management API)
 
-The backoffice (`Umbraco.Web.UI.Client`) is published to npm as **`@umbraco-cms/backoffice`** with a plugin architecture:
+When a PR changes Management API controllers or models, the `OpenApi.json` file in the Management API project must be updated:
 
-#### Architecture Overview
+1. Run the Umbraco instance locally
+2. Open Swagger UI and navigate to the swagger.json link (e.g. `https://localhost:44339/umbraco/swagger/management/swagger.json`)
+3. Copy the full JSON content and paste it into `src/Umbraco.Cms.Api.Management/OpenApi.json`
 
-- **Multi-workspace structure**: Subprojects in `src/libs/*`, `src/packages/*`, `src/external/*`
-- **Export model**: All exports defined in root `package.json` → `./exports` field
-- **Importmap-driven runtime**: Dependencies provided at runtime via importmap (single source of truth)
-- **Build-time types**: TypeScript types come from npm peerDependencies
-- **Plugin model**: Developers create plugins that import from `@umbraco-cms/backoffice/*` exports
+**Important**: Commit only the substantive changes — not IDE-applied formatting (whitespace, reordering, etc.). Extraneous formatting diffs make PRs harder to review and merge-ups more error-prone.
 
-#### Dependency Hoisting Strategy
+### Backoffice npm Package
 
-When building for npm (`npm pack`), the `cleanse-pkg.js` script hoists subproject dependencies to root `peerDependencies` with intelligent version range conversion:
-
-**Version Range Logic** (uses `semver` package):
-
-1. **Pre-release (0.x.y)**: Convert to explicit range
-   - Input: `^0.85.0` or `0.85.0`
-   - Output: `>=0.85.0 <1.0.0`
-   - Rationale: Pre-release caret only allows patch updates, explicit range allows minor upgrades within 0.x.x
-   - Example: Plugin can use `@hey-api/openapi-ts@0.91.1` while backoffice uses `0.85.0`
-
-2. **Stable with caret (^X.Y.Z where X ≥ 1)**: Keep as-is
-   - Input: `^3.3.1`
-   - Output: `^3.3.1` (unchanged)
-   - Rationale: Caret already implements correct semantics for stable versions
-
-3. **Stable exact versions (X.Y.Z where X ≥ 1)**: Add caret
-   - Input: `3.16.0`
-   - Output: `^3.16.0`
-   - Rationale: Normalizes to conventional semver format
-
-#### Key Dependencies
-
-**Runtime via importmap** (types available from peerDependencies):
-- `lit`, `rxjs`, `@umbraco-ui/uui` - Core framework
-- `monaco-editor`, `@tiptap/*` - Feature-specific editors
-- `@hey-api/openapi-ts` - HTTP client type generation
-
-**Build-time only** (not hoisted):
-- `vite`, `typescript`, `eslint` - Dev tooling
-
-#### Plugin Development Implications
-
-Plugin developers should:
-- **Declare explicit dependencies** in their own `package.json` (avoid relying on transitive deps)
-- **Understand the version ranges**: `>=0.85.0 <1.0.0` means they can use newer pre-release versions
-- **Know that types match npm ranges**, but runtime comes from importmap (managed by backoffice)
-- **When `@hey-api` hits 1.0.0**: Published constraint will automatically become `^1.0.0`
-
-#### Implementation Details
-
-- Script location: `src/Umbraco.Web.UI.Client/devops/publish/cleanse-pkg.js`
-- Runs as `prepack` hook before npm pack
-- Uses `semver.minVersion()` for robust version range parsing
-- Generates single source of truth for importmap versions
+The backoffice is published to npm as `@umbraco-cms/backoffice`. Runtime dependencies are provided via importmap; npm peerDependencies provide types only. For full details on dependency hoisting, version range logic, and plugin development, see `/src/Umbraco.Web.UI.Client/CLAUDE.md` → "npm Package Publishing".
 
 ### Known Limitations
 
@@ -520,6 +475,7 @@ The `Tests:Database:DatabaseType` setting controls which database is used:
 - `"LocalDb"` - Uses SQL Server LocalDB, required for SQL Server-specific tests (e.g., page-level locking, `sys.dm_tran_locks`)
 
 SQL Server-specific tests use `BaseTestDatabase.IsSqlite()` to skip when running on SQLite.
+
 ### Key Projects
 
 | Project | Type | Description |
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 4e9195932bf6..b84a150e8b97 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -14,7 +14,7 @@
   </ItemGroup>
   <!-- Microsoft packages -->
   <ItemGroup>
-    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation" Version="10.0.5" />
+    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Razor.RuntimeCompilation" Version="10.0.3" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="5.0.0" />
     <PackageVersion Include="Microsoft.Data.Sqlite" Version="10.0.5" />
     <PackageVersion Include="Microsoft.EntityFrameworkCore" Version="10.0.5" />
diff --git a/build/azure-pipelines.yml b/build/azure-pipelines.yml
index 338da39ae7be..7d2661c5df38 100644
--- a/build/azure-pipelines.yml
+++ b/build/azure-pipelines.yml
@@ -117,7 +117,7 @@ stages:
               artifactName: csharp-docs-dlls
           - powershell: |
               dotnet tool install --global CycloneDX
-              dotnet-CycloneDX $(solution) --output $(Build.ArtifactStagingDirectory)/bom --filename bom-dotnet.xml
+              dotnet-CycloneDX $(solution) --spec-version 1.5 --output $(Build.ArtifactStagingDirectory)/bom --filename bom-dotnet.xml
             displayName: 'Generate Backend BOM'
           - powershell: |
               npm install --global @cyclonedx/cyclonedx-npm
@@ -614,7 +614,6 @@ stages:
       UMBRACO__CMS__GLOBAL__VERSIONCHECKPERIOD: 0
       UMBRACO__CMS__GLOBAL__USEHTTPS: true
       UMBRACO__CMS__HEALTHCHECKS__NOTIFICATION__ENABLED: false
-      UMBRACO__CMS__KEEPALIVE__DISABLEKEEPALIVETASK: true
       UMBRACO__CMS__WEBROUTING__UMBRACOAPPLICATIONURL: https://localhost:44331/
       ASPNETCORE_URLS: https://localhost:44331
     jobs:
@@ -867,6 +866,40 @@ stages:
               npm publish "${files[0]}"
             displayName: Push to npm (MyGet)
             workingDirectory: $(Pipeline.Workspace)/npm
+      - job: PublishTestHelpersNpm
+        displayName: Push TestHelpers to pre-release feed (npm)
+        steps:
+          - checkout: none
+          - download: current
+            artifact: npm-testhelpers
+          - bash: |
+              # Check if we are on a nightly build
+              if [ $isNightly = "False" ]; then
+                  echo "##[debug]Prerelease build detected"
+                  registry="https://www.myget.org/F/umbracoprereleases/npm/"
+              else
+                  echo "##[debug]Nightly build detected"
+                  registry="https://www.myget.org/F/umbraconightly/npm/"
+              fi
+              echo "@umbraco-cms:registry=$registry" >> .npmrc
+            env:
+              isNightly: ${{parameters.isNightly}}
+            workingDirectory: $(Pipeline.Workspace)/npm-testhelpers
+            displayName: Add scoped registry to .npmrc
+          - task: npmAuthenticate@0
+            displayName: Authenticate with npm (MyGet)
+            inputs:
+              workingFile: "$(Pipeline.Workspace)/npm-testhelpers/.npmrc"
+              customEndpoint: "MyGet (npm) - Umbracoprereleases, MyGet (npm) - Umbraconightly"
+          - bash: |
+              # Setup temp npm project to load in defaults from the local .npmrc
+              npm init -y
+
+              # Find the first .tgz file in the current directory and publish it
+              files=( ./*.tgz )
+              npm publish "${files[0]}"
+            displayName: Push test helpers to npm (MyGet)
+            workingDirectory: $(Pipeline.Workspace)/npm-testhelpers
 
   - stage: Deploy_NuGet
     displayName: NuGet release
@@ -927,7 +960,7 @@ stages:
           - checkout: none
           - download: current
             artifact: npm-testhelpers
-          - bash: echo "@umbraco:registry=https://registry.npmjs.org" >> .npmrc
+          - bash: echo "@umbraco-cms:registry=https://registry.npmjs.org" >> .npmrc
             workingDirectory: $(Pipeline.Workspace)/npm-testhelpers
             displayName: Add scoped registry to .npmrc
           - task: npmAuthenticate@0
diff --git a/build/nightly-E2E-test-pipelines.yml b/build/nightly-E2E-test-pipelines.yml
index f12f764b0499..aeb2fd50fe71 100644
--- a/build/nightly-E2E-test-pipelines.yml
+++ b/build/nightly-E2E-test-pipelines.yml
@@ -339,7 +339,6 @@ stages:
       UMBRACO__CMS__GLOBAL__VERSIONCHECKPERIOD: 0
       UMBRACO__CMS__GLOBAL__USEHTTPS: true
       UMBRACO__CMS__HEALTHCHECKS__NOTIFICATION__ENABLED: false
-      UMBRACO__CMS__KEEPALIVE__DISABLEKEEPALIVETASK: true
       UMBRACO__CMS__WEBROUTING__UMBRACOAPPLICATIONURL: https://localhost:44331/
       ASPNETCORE_URLS: https://localhost:44331
     jobs:
diff --git a/src/Umbraco.Cms.Api.Common/DependencyInjection/HideBackOfficeTokensHandler.cs b/src/Umbraco.Cms.Api.Common/DependencyInjection/HideBackOfficeTokensHandler.cs
index bc80e9276e8f..8236a922649f 100644
--- a/src/Umbraco.Cms.Api.Common/DependencyInjection/HideBackOfficeTokensHandler.cs
+++ b/src/Umbraco.Cms.Api.Common/DependencyInjection/HideBackOfficeTokensHandler.cs
@@ -1,6 +1,8 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Security.Cryptography;
 using Microsoft.AspNetCore.DataProtection;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using OpenIddict.Abstractions;
 using OpenIddict.Server;
@@ -41,6 +43,7 @@ internal sealed class HideBackOfficeTokensHandler
 
     private readonly IHttpContextAccessor _httpContextAccessor;
     private readonly IDataProtectionProvider _dataProtectionProvider;
+    private readonly ILogger<HideBackOfficeTokensHandler> _logger;
 #pragma warning disable CS0618 // Type or member is obsolete
     private readonly BackOfficeTokenCookieSettings _backOfficeTokenCookieSettings;
 #pragma warning restore CS0618 // Type or member is obsolete
@@ -51,11 +54,13 @@ internal sealed class HideBackOfficeTokensHandler
     /// </summary>
     /// <param name="httpContextAccessor">The HTTP context accessor.</param>
     /// <param name="dataProtectionProvider">The data protection provider for encrypting cookie values.</param>
+    /// <param name="logger">The logger.</param>
     /// <param name="backOfficeTokenCookieSettings">The back-office token cookie settings.</param>
     /// <param name="globalSettings">The global settings.</param>
     public HideBackOfficeTokensHandler(
         IHttpContextAccessor httpContextAccessor,
         IDataProtectionProvider dataProtectionProvider,
+        ILogger<HideBackOfficeTokensHandler> logger,
 #pragma warning disable CS0618 // Type or member is obsolete
         IOptions<BackOfficeTokenCookieSettings> backOfficeTokenCookieSettings,
 #pragma warning restore CS0618 // Type or member is obsolete
@@ -63,6 +68,7 @@ public HideBackOfficeTokensHandler(
     {
         _httpContextAccessor = httpContextAccessor;
         _dataProtectionProvider = dataProtectionProvider;
+        _logger = logger;
         _backOfficeTokenCookieSettings = backOfficeTokenCookieSettings.Value;
         _globalSettings = globalSettings.Value;
 
@@ -291,8 +297,19 @@ private bool TryGetCookie(HttpContext httpContext, string cookieName, [NotNullWh
         var key = GetCookieKey(httpContext, cookieName);
         if (httpContext.Request.Cookies.TryGetValue(key, out var cookieValue))
         {
-            value = EncryptionHelper.Decrypt(cookieValue, _dataProtectionProvider);
-            return true;
+            try
+            {
+                value = EncryptionHelper.Decrypt(cookieValue, _dataProtectionProvider);
+                return true;
+            }
+            catch (CryptographicException ex)
+            {
+                // Decryption can fail if the data protection key ring has changed
+                // (e.g., after deployment, app pool recycle, or slot swap).
+                // Treat this as a missing cookie — the user will need to re-authenticate.
+                _logger.LogWarning(ex, "Failed to decrypt back-office token cookie '{CookieName}'. The user will need to re-authenticate.", cookieName);
+                RemoveCookie(httpContext, cookieName);
+            }
         }
 
         value = null;
diff --git a/src/Umbraco.Cms.Api.Delivery/Indexing/Selectors/AncestorsSelectorIndexer.cs b/src/Umbraco.Cms.Api.Delivery/Indexing/Selectors/AncestorsSelectorIndexer.cs
index e70faeab67a6..f0624b0ca137 100644
--- a/src/Umbraco.Cms.Api.Delivery/Indexing/Selectors/AncestorsSelectorIndexer.cs
+++ b/src/Umbraco.Cms.Api.Delivery/Indexing/Selectors/AncestorsSelectorIndexer.cs
@@ -1,12 +1,13 @@
 using Umbraco.Cms.Core.DeliveryApi;
 using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Infrastructure.Examine;
 
 namespace Umbraco.Cms.Api.Delivery.Indexing.Selectors;
 
 public sealed class AncestorsSelectorIndexer : IContentIndexHandler
 {
     // NOTE: "id" is a reserved field name
-    internal const string FieldName = "itemId";
+    internal const string FieldName = UmbracoExamineFieldNames.DeliveryApiContentIndex.ItemId;
 
     public IEnumerable<IndexFieldValue> GetFieldValues(IContent content, string? culture)
         => new[] { new IndexFieldValue { FieldName = FieldName, Values = new object[] { content.Key } } };
diff --git a/src/Umbraco.Cms.Api.Delivery/Services/ApiContentQueryProvider.cs b/src/Umbraco.Cms.Api.Delivery/Services/ApiContentQueryProvider.cs
index 07453476f68c..b1253a4244ba 100644
--- a/src/Umbraco.Cms.Api.Delivery/Services/ApiContentQueryProvider.cs
+++ b/src/Umbraco.Cms.Api.Delivery/Services/ApiContentQueryProvider.cs
@@ -17,7 +17,7 @@ namespace Umbraco.Cms.Api.Delivery.Services;
 /// </summary>
 internal sealed class ApiContentQueryProvider : IApiContentQueryProvider
 {
-    private const string ItemIdFieldName = "itemId";
+    private const string ItemIdFieldName = UmbracoExamineFieldNames.DeliveryApiContentIndex.ItemId;
     private readonly IExamineManager _examineManager;
     private readonly ILogger<ApiContentQueryProvider> _logger;
     private readonly ApiContentQuerySelectorBuilder _selectorBuilder;
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/DataType/Tree/DataTypeTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/DataType/Tree/DataTypeTreeControllerBase.cs
index b28b5e0a306a..be4f1d00eae9 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/DataType/Tree/DataTypeTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/DataType/Tree/DataTypeTreeControllerBase.cs
@@ -60,17 +60,17 @@ protected override Ordering ItemOrdering
         }
     }
 
-    protected override DataTypeTreeItemResponseModel[] MapTreeItemViewModels(Guid? parentId, IEntitySlim[] entities)
+    protected override async Task<DataTypeTreeItemResponseModel[]> MapTreeItemViewModelsAsync(Guid? parentId, IEntitySlim[] entities)
     {
         Dictionary<int, IDataType> dataTypes = entities.Any()
-            ? _dataTypeService
-                .GetAllAsync(entities.Select(entity => entity.Key).ToArray()).GetAwaiter().GetResult()
+            ? (await _dataTypeService
+                .GetAllAsync(entities.Select(entity => entity.Key).ToArray()))
                 .ToDictionary(contentType => contentType.Id)
             : new Dictionary<int, IDataType>();
 
-        return entities.Select(entity =>
+        IEnumerable<Task<DataTypeTreeItemResponseModel>> tasks = entities.Select(async entity =>
         {
-            DataTypeTreeItemResponseModel responseModel = MapTreeItemViewModel(parentId, entity);
+            DataTypeTreeItemResponseModel responseModel = await MapTreeItemViewModelAsync(parentId, entity);
             if (dataTypes.TryGetValue(entity.Id, out IDataType? dataType))
             {
                 responseModel.EditorUiAlias = dataType.EditorUiAlias;
@@ -78,6 +78,8 @@ protected override DataTypeTreeItemResponseModel[] MapTreeItemViewModels(Guid? p
             }
 
             return responseModel;
-        }).ToArray();
+        });
+
+        return await Task.WhenAll(tasks);
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Document/Item/ItemDocumentItemController.cs b/src/Umbraco.Cms.Api.Management/Controllers/Document/Item/ItemDocumentItemController.cs
index 4d30a12cd1e9..471c0a259def 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Document/Item/ItemDocumentItemController.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Document/Item/ItemDocumentItemController.cs
@@ -57,7 +57,8 @@ public async Task<IActionResult> Item(
             .GetAll(UmbracoObjectTypes.Document, ids.ToArray())
             .OfType<IDocumentEntitySlim>();
 
-        IEnumerable<DocumentItemResponseModel> responseModels = documents.Select(_documentPresentationFactory.CreateItemResponseModel);
+        IEnumerable<Task<DocumentItemResponseModel>> tasks = documents.Select(_documentPresentationFactory.CreateItemResponseModelAsync);
+        DocumentItemResponseModel[] responseModels = await Task.WhenAll(tasks);
         return Ok(responseModels);
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Document/Item/SearchDocumentItemController.cs b/src/Umbraco.Cms.Api.Management/Controllers/Document/Item/SearchDocumentItemController.cs
index d880e0106c89..554bd8fd11ae 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Document/Item/SearchDocumentItemController.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Document/Item/SearchDocumentItemController.cs
@@ -78,9 +78,12 @@ public async Task<IActionResult> SearchWithTrashed(
             take,
             ignoreUserStartNodes);
 
+        IEnumerable<Task<DocumentItemResponseModel>> tasks = searchResult.Items.OfType<IDocumentEntitySlim>().Select(_documentPresentationFactory.CreateItemResponseModelAsync);
+        DocumentItemResponseModel[] items = await Task.WhenAll(tasks);
+
         var result = new PagedModel<DocumentItemResponseModel>
         {
-            Items = searchResult.Items.OfType<IDocumentEntitySlim>().Select(_documentPresentationFactory.CreateItemResponseModel),
+            Items = items,
             Total = searchResult.Total,
         };
 
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Document/RecycleBin/DocumentRecycleBinControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Document/RecycleBin/DocumentRecycleBinControllerBase.cs
index b4560779bc0c..c7e2f5332c8d 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Document/RecycleBin/DocumentRecycleBinControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Document/RecycleBin/DocumentRecycleBinControllerBase.cs
@@ -39,13 +39,13 @@ public DocumentRecycleBinControllerBase(IEntityService entityService, IDocumentP
 
     protected override Guid RecycleBinRootKey => Constants.System.RecycleBinContentKey;
 
-    protected override DocumentRecycleBinItemResponseModel MapRecycleBinViewModel(Guid? parentId, IEntitySlim entity)
+    protected override async Task<DocumentRecycleBinItemResponseModel> MapRecycleBinViewModelAsync(Guid? parentId, IEntitySlim entity)
     {
-        DocumentRecycleBinItemResponseModel responseModel = base.MapRecycleBinViewModel(parentId, entity);
+        DocumentRecycleBinItemResponseModel responseModel = await base.MapRecycleBinViewModelAsync(parentId, entity);
 
         if (entity is IDocumentEntitySlim documentEntitySlim)
         {
-            responseModel.Variants = _documentPresentationFactory.CreateVariantsItemResponseModels(documentEntitySlim);
+            responseModel.Variants = await _documentPresentationFactory.CreateVariantsItemResponseModelsAsync(documentEntitySlim);
             responseModel.DocumentType = _documentPresentationFactory.CreateDocumentTypeReferenceResponseModel(documentEntitySlim);
         }
 
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Document/Tree/DocumentTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Document/Tree/DocumentTreeControllerBase.cs
index 428fe46d90ef..92f505855796 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Document/Tree/DocumentTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Document/Tree/DocumentTreeControllerBase.cs
@@ -81,9 +81,9 @@ protected DocumentTreeControllerBase(
 
     protected override Ordering ItemOrdering => Ordering.By(Infrastructure.Persistence.Dtos.NodeDto.SortOrderColumnName);
 
-    protected override DocumentTreeItemResponseModel MapTreeItemViewModel(Guid? parentId, IEntitySlim entity)
+    protected override async Task<DocumentTreeItemResponseModel> MapTreeItemViewModelAsync(Guid? parentId, IEntitySlim entity)
     {
-        DocumentTreeItemResponseModel responseModel = base.MapTreeItemViewModel(parentId, entity);
+        DocumentTreeItemResponseModel responseModel = await base.MapTreeItemViewModelAsync(parentId, entity);
 
         if (entity is IDocumentEntitySlim documentEntitySlim)
         {
@@ -94,7 +94,7 @@ protected override DocumentTreeItemResponseModel MapTreeItemViewModel(Guid? pare
             responseModel.Id = entity.Key;
             responseModel.CreateDate = entity.CreateDate;
 
-            responseModel.Variants = _documentPresentationFactory.CreateVariantsItemResponseModels(documentEntitySlim);
+            responseModel.Variants = await _documentPresentationFactory.CreateVariantsItemResponseModelsAsync(documentEntitySlim);
             responseModel.DocumentType = _documentPresentationFactory.CreateDocumentTypeReferenceResponseModel(documentEntitySlim);
         }
 
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/DocumentBlueprint/GetAuditLogDocumentBlueprintController.cs b/src/Umbraco.Cms.Api.Management/Controllers/DocumentBlueprint/GetAuditLogDocumentBlueprintController.cs
new file mode 100644
index 000000000000..0a2f6073d4e5
--- /dev/null
+++ b/src/Umbraco.Cms.Api.Management/Controllers/DocumentBlueprint/GetAuditLogDocumentBlueprintController.cs
@@ -0,0 +1,47 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.AuditLog;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DocumentBlueprint;
+
+[ApiVersion("1.0")]
+[Authorize(Policy = AuthorizationPolicies.TreeAccessDocumentTypes)]
+public class GetAuditLogDocumentBlueprintController : DocumentBlueprintControllerBase
+{
+    private readonly IAuditService _auditService;
+    private readonly IAuditLogPresentationFactory _auditLogPresentationFactory;
+
+    public GetAuditLogDocumentBlueprintController(
+        IAuditService auditService,
+        IAuditLogPresentationFactory auditLogPresentationFactory)
+    {
+        _auditService = auditService;
+        _auditLogPresentationFactory = auditLogPresentationFactory;
+    }
+
+    [MapToApiVersion("1.0")]
+    [HttpGet("{id:guid}/audit-log")]
+    [ProducesResponseType(typeof(PagedViewModel<AuditLogResponseModel>), StatusCodes.Status200OK)]
+    [EndpointSummary("Gets the audit log for a document blueprint.")]
+    [EndpointDescription("Gets a paginated collection of audit log entries for the document blueprint identified by the provided Id.")]
+    public async Task<IActionResult> GetAuditLog(CancellationToken cancellationToken, Guid id, Direction orderDirection = Direction.Descending, DateTimeOffset? sinceDate = null, int skip = 0, int take = 100)
+    {
+        PagedModel<IAuditItem> result = await _auditService.GetItemsByKeyAsync(id, UmbracoObjectTypes.DocumentBlueprint, skip, take, orderDirection, sinceDate);
+        IEnumerable<AuditLogResponseModel> mapped = _auditLogPresentationFactory.CreateAuditLogViewModel(result.Items);
+        var viewModel = new PagedViewModel<AuditLogResponseModel>
+        {
+            Total = result.Total,
+            Items = mapped,
+        };
+
+        return Ok(viewModel);
+    }
+}
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/DocumentBlueprint/Tree/DocumentBlueprintTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/DocumentBlueprint/Tree/DocumentBlueprintTreeControllerBase.cs
index 4bad663f80dd..29683492e486 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/DocumentBlueprint/Tree/DocumentBlueprintTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/DocumentBlueprint/Tree/DocumentBlueprintTreeControllerBase.cs
@@ -66,15 +66,19 @@ protected override Ordering ItemOrdering
         }
     }
 
-    protected override DocumentBlueprintTreeItemResponseModel[] MapTreeItemViewModels(Guid? parentId, IEntitySlim[] entities)
-        => entities.Select(entity =>
+    protected override async Task<DocumentBlueprintTreeItemResponseModel[]> MapTreeItemViewModelsAsync(Guid? parentId, IEntitySlim[] entities)
+    {
+        IEnumerable<Task<DocumentBlueprintTreeItemResponseModel>> tasks = entities.Select(async entity =>
         {
-            DocumentBlueprintTreeItemResponseModel responseModel = MapTreeItemViewModel(parentId, entity);
+            DocumentBlueprintTreeItemResponseModel responseModel = await MapTreeItemViewModelAsync(parentId, entity);
             if (entity is IDocumentEntitySlim documentEntitySlim)
             {
                 responseModel.HasChildren = false;
                 responseModel.DocumentType = _documentPresentationFactory.CreateDocumentTypeReferenceResponseModel(documentEntitySlim);
             }
             return responseModel;
-        }).ToArray();
+        });
+
+        return await Task.WhenAll(tasks);
+    }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/DocumentType/DocumentTypeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/DocumentType/DocumentTypeControllerBase.cs
index b81adb343927..2a09cc00f771 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/DocumentType/DocumentTypeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/DocumentType/DocumentTypeControllerBase.cs
@@ -94,6 +94,10 @@ status is ContentTypeOperationStatus.Success
                     .WithTitle("Operation not permitted")
                     .WithDetail("The attempted operation was not permitted, likely due to a permission/configuration mismatch with the operation.")
                     .Build()),
+                ContentTypeOperationStatus.SystemAliasChangeNotAllowed => new BadRequestObjectResult(problemDetailsBuilder
+                    .WithTitle("Alias change not permitted")
+                    .WithDetail($"The alias of a system {type} type cannot be changed. To create a {type} type with a different alias, use the duplicate operation instead.")
+                    .Build()),
                 ContentTypeOperationStatus.CancelledByNotification => new BadRequestObjectResult(problemDetailsBuilder
                     .WithTitle("Cancelled by notification")
                     .WithDetail("The attempted operation was cancelled by a notification.")
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/DocumentType/Tree/DocumentTypeTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/DocumentType/Tree/DocumentTypeTreeControllerBase.cs
index 7b110d84d3e9..9a2126b26e6f 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/DocumentType/Tree/DocumentTypeTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/DocumentType/Tree/DocumentTypeTreeControllerBase.cs
@@ -55,15 +55,15 @@ public DocumentTypeTreeControllerBase(
 
     protected override UmbracoObjectTypes FolderObjectType => UmbracoObjectTypes.DocumentTypeContainer;
 
-    protected override DocumentTypeTreeItemResponseModel[] MapTreeItemViewModels(Guid? parentKey, IEntitySlim[] entities)
+    protected override async Task<DocumentTypeTreeItemResponseModel[]> MapTreeItemViewModelsAsync(Guid? parentKey, IEntitySlim[] entities)
     {
         var contentTypes = _contentTypeService
             .GetMany(entities.Select(entity => entity.Id).ToArray())
             .ToDictionary(contentType => contentType.Id);
 
-        return entities.Select(entity =>
+        IEnumerable<Task<DocumentTypeTreeItemResponseModel>> tasks = entities.Select(async entity =>
         {
-            DocumentTypeTreeItemResponseModel responseModel = MapTreeItemViewModel(parentKey, entity);
+            DocumentTypeTreeItemResponseModel responseModel = await MapTreeItemViewModelAsync(parentKey, entity);
             if (contentTypes.TryGetValue(entity.Id, out IContentType? contentType))
             {
                 responseModel.Icon = contentType.Icon ?? responseModel.Icon;
@@ -71,6 +71,8 @@ protected override DocumentTypeTreeItemResponseModel[] MapTreeItemViewModels(Gui
             }
 
             return responseModel;
-        }).ToArray();
+        });
+
+        return await Task.WhenAll(tasks);
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Element/Item/ItemElementItemController.cs b/src/Umbraco.Cms.Api.Management/Controllers/Element/Item/ItemElementItemController.cs
index f6e53805f905..1e4a86f0bf0e 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Element/Item/ItemElementItemController.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Element/Item/ItemElementItemController.cs
@@ -42,20 +42,21 @@ public ItemElementItemController(
     [ProducesResponseType(typeof(IEnumerable<ElementItemResponseModel>), StatusCodes.Status200OK)]
     [EndpointSummary("Gets a collection of element items.")]
     [EndpointDescription("Gets a collection of element items identified by the provided Ids.")]
-    public Task<IActionResult> Item(
+    public async Task<IActionResult> Item(
         CancellationToken cancellationToken,
         [FromQuery(Name = "id")] HashSet<Guid> ids)
     {
         if (ids.Count is 0)
         {
-            return Task.FromResult<IActionResult>(Ok(Enumerable.Empty<ElementItemResponseModel>()));
+            return Ok(Enumerable.Empty<ElementItemResponseModel>());
         }
 
         IEnumerable<IElementEntitySlim> elements = _entityService
             .GetAll(UmbracoObjectTypes.Element, ids.ToArray())
             .OfType<IElementEntitySlim>();
 
-        IEnumerable<ElementItemResponseModel> responseModels = elements.Select(_elementPresentationFactory.CreateItemResponseModel);
-        return Task.FromResult<IActionResult>(Ok(responseModels));
+        IEnumerable<Task<ElementItemResponseModel>> tasks = elements.Select(_elementPresentationFactory.CreateItemResponseModelAsync);
+        ElementItemResponseModel[] responseModels = await Task.WhenAll(tasks);
+        return Ok(responseModels);
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Element/RecycleBin/ElementRecycleBinControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Element/RecycleBin/ElementRecycleBinControllerBase.cs
index b102c901d4c4..36c26281b9fd 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Element/RecycleBin/ElementRecycleBinControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Element/RecycleBin/ElementRecycleBinControllerBase.cs
@@ -47,15 +47,15 @@ public ElementRecycleBinControllerBase( IEntityService entityService, IElementPr
 
     protected override Guid RecycleBinRootKey => Constants.System.RecycleBinElementKey;
 
-    protected override ElementRecycleBinItemResponseModel MapRecycleBinViewModel(Guid? parentId, IEntitySlim entity)
+    protected override async Task<ElementRecycleBinItemResponseModel> MapRecycleBinViewModelAsync(Guid? parentId, IEntitySlim entity)
     {
-        ElementRecycleBinItemResponseModel responseModel = base.MapRecycleBinViewModel(parentId, entity);
+        ElementRecycleBinItemResponseModel responseModel = await base.MapRecycleBinViewModelAsync(parentId, entity);
 
         responseModel.Name = entity.Name ?? string.Empty;
 
         if (entity is IElementEntitySlim elementEntitySlim)
         {
-            responseModel.Variants = _elementPresentationFactory.CreateVariantsItemResponseModels(elementEntitySlim);
+            responseModel.Variants = await _elementPresentationFactory.CreateVariantsItemResponseModelsAsync(elementEntitySlim);
             responseModel.DocumentType = _elementPresentationFactory.CreateDocumentTypeReferenceResponseModel(elementEntitySlim);
             responseModel.IsFolder = false;
         }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/ChildrenElementTreeController.cs b/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/ChildrenElementTreeController.cs
index b91fec165753..8e8836eb1357 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/ChildrenElementTreeController.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/ChildrenElementTreeController.cs
@@ -41,15 +41,17 @@ public ChildrenElementTreeController(
     /// <param name="skip">The number of items to skip for pagination.</param>
     /// <param name="take">The number of items to return for pagination.</param>
     /// <param name="foldersOnly">Whether to return only folder items.</param>
+    /// <param name="dataTypeId">An optional data type identifier to filter the element items.</param>
     /// <returns>A paginated collection of child element tree items.</returns>
     [HttpGet("children")]
     [MapToApiVersion("1.0")]
     [ProducesResponseType(typeof(PagedViewModel<ElementTreeItemResponseModel>), StatusCodes.Status200OK)]
     [EndpointSummary("Gets a collection of element tree child items.")]
     [EndpointDescription("Gets a paginated collection of element tree items that are children of the provided parent Id.")]
-    public async Task<ActionResult<PagedViewModel<ElementTreeItemResponseModel>>> Children(CancellationToken cancellationToken, Guid parentId, int skip = 0, int take = 100, bool foldersOnly = false)
+    public async Task<ActionResult<PagedViewModel<ElementTreeItemResponseModel>>> Children(CancellationToken cancellationToken, Guid parentId, int skip = 0, int take = 100, bool foldersOnly = false, Guid? dataTypeId = null)
     {
         RenderFoldersOnly(foldersOnly);
+        IgnoreUserStartNodesForDataType(dataTypeId);
         return await GetChildren(parentId, skip, take);
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/ElementTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/ElementTreeControllerBase.cs
index 192516e2fb40..f69c32e26af0 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/ElementTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/ElementTreeControllerBase.cs
@@ -77,23 +77,23 @@ protected override string[] GetUserStartNodePaths()
                .GetElementStartNodePaths(EntityService, _appCaches)
            ?? [];
 
-    protected override ElementTreeItemResponseModel MapTreeItemViewModel(Guid? parentKey, IEntitySlim entity)
+    protected override async Task<ElementTreeItemResponseModel> MapTreeItemViewModelAsync(Guid? parentKey, IEntitySlim entity)
     {
-        ElementTreeItemResponseModel responseModel = base.MapTreeItemViewModel(parentKey, entity);
+        ElementTreeItemResponseModel responseModel = await base.MapTreeItemViewModelAsync(parentKey, entity);
 
         if (entity is IElementEntitySlim elementEntitySlim)
         {
             responseModel.CreateDate = elementEntitySlim.CreateDate;
             responseModel.DocumentType = _elementPresentationFactory.CreateDocumentTypeReferenceResponseModel(elementEntitySlim);
-            responseModel.Variants = _elementPresentationFactory.CreateVariantsItemResponseModels(elementEntitySlim);
+            responseModel.Variants = await _elementPresentationFactory.CreateVariantsItemResponseModelsAsync(elementEntitySlim);
         }
 
         return responseModel;
     }
 
-    protected override ElementTreeItemResponseModel MapTreeItemViewModelAsNoAccess(Guid? parentKey, IEntitySlim entity)
+    protected override async Task<ElementTreeItemResponseModel> MapTreeItemViewModelAsNoAccessAsync(Guid? parentKey, IEntitySlim entity)
     {
-        ElementTreeItemResponseModel viewModel = MapTreeItemViewModel(parentKey, entity);
+        ElementTreeItemResponseModel viewModel = await MapTreeItemViewModelAsync(parentKey, entity);
         viewModel.NoAccess = true;
         return viewModel;
     }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/RootElementTreeController.cs b/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/RootElementTreeController.cs
index 38cdb3b12834..332822df9408 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/RootElementTreeController.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/RootElementTreeController.cs
@@ -40,6 +40,7 @@ public RootElementTreeController(
     /// <param name="skip">The number of items to skip for pagination.</param>
     /// <param name="take">The number of items to return for pagination.</param>
     /// <param name="foldersOnly">Whether to return only folder items.</param>
+    /// <param name="dataTypeId">An optional identifier to filter element items by data type.</param>
     /// <returns>A paginated collection of root element tree items.</returns>
     [HttpGet("root")]
     [MapToApiVersion("1.0")]
@@ -50,9 +51,11 @@ public async Task<ActionResult<PagedViewModel<ElementTreeItemResponseModel>>> Ro
         CancellationToken cancellationToken,
         int skip = 0,
         int take = 100,
-        bool foldersOnly = false)
+        bool foldersOnly = false,
+        Guid? dataTypeId = null)
     {
         RenderFoldersOnly(foldersOnly);
+        IgnoreUserStartNodesForDataType(dataTypeId);
         return await GetRoot(skip, take);
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/SiblingsElementTreeController.cs b/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/SiblingsElementTreeController.cs
index 8807c24b6968..f86bd90f3b5d 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/SiblingsElementTreeController.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Element/Tree/SiblingsElementTreeController.cs
@@ -41,6 +41,7 @@ public SiblingsElementTreeController(
     /// <param name="before">The number of sibling items to retrieve before the target.</param>
     /// <param name="after">The number of sibling items to retrieve after the target.</param>
     /// <param name="foldersOnly">Whether to return only folder items.</param>
+    /// <param name="dataTypeId">An optional data type identifier to filter the sibling items.</param>
     /// <returns>A subset collection of sibling element tree items.</returns>
     [HttpGet("siblings")]
     [MapToApiVersion("1.0")]
@@ -52,9 +53,11 @@ public async Task<ActionResult<SubsetViewModel<ElementTreeItemResponseModel>>> S
         Guid target,
         int before,
         int after,
-        bool foldersOnly = false)
+        bool foldersOnly = false,
+        Guid? dataTypeId = null)
     {
         RenderFoldersOnly(foldersOnly);
+        IgnoreUserStartNodesForDataType(dataTypeId);
         return await GetSiblings(target, before, after);
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Media/RecycleBin/MediaRecycleBinControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Media/RecycleBin/MediaRecycleBinControllerBase.cs
index bd7118eddc60..5c8162961ed1 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Media/RecycleBin/MediaRecycleBinControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Media/RecycleBin/MediaRecycleBinControllerBase.cs
@@ -39,9 +39,9 @@ public MediaRecycleBinControllerBase(IEntityService entityService, IMediaPresent
 
     protected override Guid RecycleBinRootKey => Constants.System.RecycleBinMediaKey;
 
-    protected override MediaRecycleBinItemResponseModel MapRecycleBinViewModel(Guid? parentKey, IEntitySlim entity)
+    protected override async Task<MediaRecycleBinItemResponseModel> MapRecycleBinViewModelAsync(Guid? parentKey, IEntitySlim entity)
     {
-        MediaRecycleBinItemResponseModel responseModel = base.MapRecycleBinViewModel(parentKey, entity);
+        MediaRecycleBinItemResponseModel responseModel = await base.MapRecycleBinViewModelAsync(parentKey, entity);
 
         if (entity is IMediaEntitySlim mediaEntitySlim)
         {
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Media/Tree/MediaTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Media/Tree/MediaTreeControllerBase.cs
index 4aa0164c42c4..620640e62a1a 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Media/Tree/MediaTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Media/Tree/MediaTreeControllerBase.cs
@@ -57,9 +57,9 @@ public MediaTreeControllerBase(
 
     protected override Ordering ItemOrdering => Ordering.By(Infrastructure.Persistence.Dtos.NodeDto.SortOrderColumnName);
 
-    protected override MediaTreeItemResponseModel MapTreeItemViewModel(Guid? parentKey, IEntitySlim entity)
+    protected override async Task<MediaTreeItemResponseModel> MapTreeItemViewModelAsync(Guid? parentKey, IEntitySlim entity)
     {
-        MediaTreeItemResponseModel responseModel = base.MapTreeItemViewModel(parentKey, entity);
+        MediaTreeItemResponseModel responseModel = await base.MapTreeItemViewModelAsync(parentKey, entity);
 
         if (entity is IMediaEntitySlim mediaEntitySlim)
         {
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/MediaType/Tree/MediaTypeTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/MediaType/Tree/MediaTypeTreeControllerBase.cs
index e3d7540b5a2e..1d05f657df25 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/MediaType/Tree/MediaTypeTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/MediaType/Tree/MediaTypeTreeControllerBase.cs
@@ -56,15 +56,15 @@ public MediaTypeTreeControllerBase(
 
     protected override UmbracoObjectTypes FolderObjectType => UmbracoObjectTypes.MediaTypeContainer;
 
-    protected override MediaTypeTreeItemResponseModel[] MapTreeItemViewModels(Guid? parentKey, IEntitySlim[] entities)
+    protected override async Task<MediaTypeTreeItemResponseModel[]> MapTreeItemViewModelsAsync(Guid? parentKey, IEntitySlim[] entities)
     {
         var mediaTypes = _mediaTypeService
             .GetMany(entities.Select(entity => entity.Id).ToArray())
             .ToDictionary(contentType => contentType.Id);
 
-        return entities.Select(entity =>
+        IEnumerable<Task<MediaTypeTreeItemResponseModel>> tasks = entities.Select(async entity =>
         {
-            MediaTypeTreeItemResponseModel responseModel = MapTreeItemViewModel(parentKey, entity);
+            MediaTypeTreeItemResponseModel responseModel = await MapTreeItemViewModelAsync(parentKey, entity);
             if (mediaTypes.TryGetValue(entity.Id, out IMediaType? mediaType))
             {
                 responseModel.Icon = mediaType.Icon ?? responseModel.Icon;
@@ -72,6 +72,8 @@ protected override MediaTypeTreeItemResponseModel[] MapTreeItemViewModels(Guid?
             }
 
             return responseModel;
-        }).ToArray();
+        });
+
+        return await Task.WhenAll(tasks);
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/MemberGroup/Tree/MemberGroupTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/MemberGroup/Tree/MemberGroupTreeControllerBase.cs
index 0fef1b819c39..83f52c0a5d13 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/MemberGroup/Tree/MemberGroupTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/MemberGroup/Tree/MemberGroupTreeControllerBase.cs
@@ -25,7 +25,7 @@ public class MemberGroupTreeControllerBase : NamedEntityTreeControllerBase<Named
     /// <param name="entityService">The service used to manage and retrieve entities within the system.</param>
     /// <param name="flagProviders">A collection of providers that supply additional flags or metadata for entities.</param>
     public MemberGroupTreeControllerBase(
-        IEntityService entityService, 
+        IEntityService entityService,
         FlagProviderCollection flagProviders)
         : base(entityService, flagProviders)
     {
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/MemberType/Tree/MemberTypeTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/MemberType/Tree/MemberTypeTreeControllerBase.cs
index d1010b6c8b0b..f7a8309fddba 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/MemberType/Tree/MemberTypeTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/MemberType/Tree/MemberTypeTreeControllerBase.cs
@@ -56,21 +56,23 @@ public MemberTypeTreeControllerBase(
 
     protected override UmbracoObjectTypes FolderObjectType => UmbracoObjectTypes.MemberTypeContainer;
 
-    protected override MemberTypeTreeItemResponseModel[] MapTreeItemViewModels(Guid? parentKey, IEntitySlim[] entities)
+    protected override async Task<MemberTypeTreeItemResponseModel[]> MapTreeItemViewModelsAsync(Guid? parentKey, IEntitySlim[] entities)
     {
         var memberTypes = _memberTypeService
             .GetMany(entities.Select(entity => entity.Id).ToArray())
             .ToDictionary(contentType => contentType.Id);
 
-        return entities.Select(entity =>
+        IEnumerable<Task<MemberTypeTreeItemResponseModel>> tasks = entities.Select(async entity =>
         {
-            MemberTypeTreeItemResponseModel responseModel = MapTreeItemViewModel(parentKey, entity);
+            MemberTypeTreeItemResponseModel responseModel = await MapTreeItemViewModelAsync(parentKey, entity);
             if (memberTypes.TryGetValue(entity.Id, out IMemberType? memberType))
             {
                 responseModel.Icon = memberType.Icon ?? responseModel.Icon;
             }
 
             return responseModel;
-        }).ToArray();
+        });
+
+        return await Task.WhenAll(tasks);
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/RecycleBin/RecycleBinControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/RecycleBin/RecycleBinControllerBase.cs
index 680b4bd661b3..1b3c38b7cd09 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/RecycleBin/RecycleBinControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/RecycleBin/RecycleBinControllerBase.cs
@@ -28,26 +28,26 @@ protected RecycleBinControllerBase(IEntityService entityService)
 
     protected abstract Guid RecycleBinRootKey { get; }
 
-    protected Task<ActionResult<PagedViewModel<TItem>>> GetRoot(int skip, int take)
+    protected async Task<ActionResult<PagedViewModel<TItem>>> GetRoot(int skip, int take)
     {
         IEntitySlim[] rootEntities = GetPagedRootEntities(skip, take, out var totalItems);
 
-        TItem[] treeItemViewModels = MapRecycleBinViewModels(null, rootEntities);
+        TItem[] treeItemViewModels = await MapRecycleBinViewModelsAsync(null, rootEntities);
 
         PagedViewModel<TItem> result = PagedViewModel(treeItemViewModels, totalItems);
 
-        return Task.FromResult<ActionResult<PagedViewModel<TItem>>>(Ok(result));
+        return Ok(result);
     }
 
-    protected Task<ActionResult<PagedViewModel<TItem>>> GetChildren(Guid parentKey, int skip, int take)
+    protected async Task<ActionResult<PagedViewModel<TItem>>> GetChildren(Guid parentKey, int skip, int take)
     {
         IEntitySlim[] children = GetPagedChildEntities(parentKey, skip, take, out var totalItems);
 
-        TItem[] treeItemViewModels = MapRecycleBinViewModels(parentKey, children);
+        TItem[] treeItemViewModels = await MapRecycleBinViewModelsAsync(parentKey, children);
 
         PagedViewModel<TItem> result = PagedViewModel(treeItemViewModels, totalItems);
 
-        return Task.FromResult<ActionResult<PagedViewModel<TItem>>>(Ok(result));
+        return Ok(result);
     }
 
     protected async Task<ActionResult<SubsetViewModel<TItem>>> GetSiblings(Guid target, int before, int after)
@@ -61,14 +61,14 @@ protected async Task<ActionResult<SubsetViewModel<TItem>>> GetSiblings(Guid targ
         IEntitySlim entity = siblings.First();
         Guid? parentKey = GetParentKey(entity);
 
-        TItem[] treeItemViewModels = MapRecycleBinViewModels(parentKey, siblings);
+        TItem[] treeItemViewModels = await MapRecycleBinViewModelsAsync(parentKey, siblings);
 
         SubsetViewModel<TItem> result = SubsetViewModel(treeItemViewModels, totalBefore, totalAfter);
 
         return Ok(result);
     }
 
-    protected virtual TItem MapRecycleBinViewModel(Guid? parentKey, IEntitySlim entity)
+    protected virtual Task<TItem> MapRecycleBinViewModelAsync(Guid? parentKey, IEntitySlim entity)
     {
         if (entity == null)
         {
@@ -88,7 +88,7 @@ protected virtual TItem MapRecycleBinViewModel(Guid? parentKey, IEntitySlim enti
                 : null
         };
 
-        return viewModel;
+        return Task.FromResult(viewModel);
     }
 
     protected IActionResult OperationStatusResult(OperationResult result) =>
@@ -154,8 +154,11 @@ protected virtual IEntitySlim[] GetPagedChildEntities(Guid parentKey, int skip,
         return children;
     }
 
-    private TItem[] MapRecycleBinViewModels(Guid? parentKey, IEntitySlim[] entities)
-        => entities.Select(entity => MapRecycleBinViewModel(parentKey, entity)).ToArray();
+    private async Task<TItem[]> MapRecycleBinViewModelsAsync(Guid? parentKey, IEntitySlim[] entities)
+    {
+        IEnumerable<Task<TItem>> tasks = entities.Select(entity => MapRecycleBinViewModelAsync(parentKey, entity));
+        return await Task.WhenAll(tasks);
+    }
 
     private PagedViewModel<TItem> PagedViewModel(IEnumerable<TItem> treeItemViewModels, long totalItems)
         => new() { Total = totalItems, Items = treeItemViewModels };
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Security/ResetPasswordController.cs b/src/Umbraco.Cms.Api.Management/Controllers/Security/ResetPasswordController.cs
index e281cc1d65fe..0cb407ca9aad 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Security/ResetPasswordController.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Security/ResetPasswordController.cs
@@ -49,9 +49,13 @@ public async Task<IActionResult> RequestPasswordReset(CancellationToken cancella
 
         // If this feature is switched off in configuration, the UI will be amended to not make the request to reset password available.
         // So this is just a server-side secondary check.
+        // ApplicationUrlNotConfigured is also surfaced since it is a server-wide configuration issue, not user-specific.
         // Regardless of other status values, it will just return Ok, so you can't use this endpoint to determine whether the email exists in the system.
-        return result.Result == UserOperationStatus.CannotPasswordReset
-            ? BadRequest()
-            : Ok();
+        return result.Result switch
+        {
+            UserOperationStatus.CannotPasswordReset => BadRequest(),
+            UserOperationStatus.ApplicationUrlNotConfigured => UserOperationStatusResult(result.Result),
+            _ => Ok(),
+        };
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Security/SecurityControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Security/SecurityControllerBase.cs
index 0e500ae60ad1..f6cea30a91d0 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Security/SecurityControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Security/SecurityControllerBase.cs
@@ -33,6 +33,10 @@ protected IActionResult UserOperationStatusResult(UserOperationStatus status, Er
                 .WithTitle("Unknown failure")
                 .WithDetail(errorMessageResult?.Error?.ErrorMessage ?? "The error was unknown")
                 .Build()),
+            UserOperationStatus.ApplicationUrlNotConfigured => BadRequest(problemDetailsBuilder
+                .WithTitle("Application URL not configured")
+                .WithDetail("The application URL is not configured. Set Umbraco:CMS:WebRouting:UmbracoApplicationUrl in configuration, or change Umbraco:CMS:WebRouting:ApplicationUrlDetection to 'FirstRequest' or 'EveryRequest'.")
+                .Build()),
             _ => StatusCode(StatusCodes.Status500InternalServerError, problemDetailsBuilder
                 .WithTitle("Unknown user operation status.")
                 .Build()),
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/StaticFile/Tree/StaticFileTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/StaticFile/Tree/StaticFileTreeControllerBase.cs
index 5552322d2143..b41d7f29830c 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/StaticFile/Tree/StaticFileTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/StaticFile/Tree/StaticFileTreeControllerBase.cs
@@ -45,7 +45,7 @@ protected override string[] GetFiles(string path)
             ? Array.Empty<string>()
             : _fileSystemTreeService.GetFiles(path);
 
-    protected FileSystemTreeItemPresentationModel[] GetAncestorModels(string path, bool includeSelf)
+    protected override FileSystemTreeItemPresentationModel[] GetAncestorModels(string path, bool includeSelf)
         => IsAllowedPath(path)
             ? _fileSystemTreeService.GetAncestorModels(path, includeSelf)
             : Array.Empty<FileSystemTreeItemPresentationModel>();
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Template/Tree/TemplateTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Template/Tree/TemplateTreeControllerBase.cs
index 533680bf1c6e..1ee854b36b55 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Template/Tree/TemplateTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Template/Tree/TemplateTreeControllerBase.cs
@@ -26,7 +26,7 @@ public class TemplateTreeControllerBase : NamedEntityTreeControllerBase<NamedEnt
     /// <param name="entityService">The <see cref="IEntityService"/> used for entity operations within the template tree controller.</param>
     /// <param name="flagProviders">A collection of <see cref="FlagProviderCollection"/> used to provide additional flags or metadata for entities.</param>
     public TemplateTreeControllerBase(
-        IEntityService entityService, 
+        IEntityService entityService,
         FlagProviderCollection flagProviders)
         : base(entityService, flagProviders)
     {
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Tree/EntityTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Tree/EntityTreeControllerBase.cs
index 00fa68df4f02..184e2a34f7a0 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Tree/EntityTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Tree/EntityTreeControllerBase.cs
@@ -41,7 +41,7 @@ protected async Task<ActionResult<PagedViewModel<TItem>>> GetRoot(int skip, int
 
         (rootEntities, totalItems) = await FilterTreeEntities(rootEntities, totalItems);
 
-        TItem[] treeItemViewModels = MapTreeItemViewModels((Guid?)null, rootEntities);
+        TItem[] treeItemViewModels = await MapTreeItemViewModelsAsync((Guid?)null, rootEntities);
 
         await PopulateFlags(treeItemViewModels);
 
@@ -56,7 +56,7 @@ protected async Task<ActionResult<PagedViewModel<TItem>>> GetChildren(Guid paren
 
         (children, totalItems) = await FilterTreeEntities(children, totalItems);
 
-        TItem[] treeItemViewModels = MapTreeItemViewModels(parentId, children);
+        TItem[] treeItemViewModels = await MapTreeItemViewModelsAsync(parentId, children);
 
         await PopulateFlags(treeItemViewModels);
 
@@ -78,7 +78,7 @@ protected async Task<ActionResult<SubsetViewModel<TItem>>> GetSiblings(Guid targ
         IEntitySlim? entity = siblings.FirstOrDefault();
         Guid? parentKey = GetParentKey(entity);
 
-        TItem[] treeItemViewModels = MapTreeItemViewModels(parentKey, siblings);
+        TItem[] treeItemViewModels = await MapTreeItemViewModelsAsync(parentKey, siblings);
 
         await PopulateFlags(treeItemViewModels);
 
@@ -137,7 +137,7 @@ protected virtual async Task<ActionResult<IEnumerable<TItem>>> GetAncestors(Guid
         // All ancestors should be present in the collection, but we defensively use
         // SingleOrDefault to handle potential data inconsistencies (e.g. after upgrades).
         List<int>? missingParentIds = null;
-        TItem[] treeItemViewModels = ancestorEntities
+        IEnumerable<Task<TItem>> tasks = ancestorEntities
             .Select(ancestor =>
             {
                 IEntitySlim? parent = ancestor.ParentId > 0
@@ -150,9 +150,9 @@ protected virtual async Task<ActionResult<IEnumerable<TItem>>> GetAncestors(Guid
                     missingParentIds.Add(ancestor.ParentId);
                 }
 
-                return MapTreeItemViewModel(parent?.Key, ancestor);
-            })
-            .ToArray();
+                return MapTreeItemViewModelAsync(parent?.Key, ancestor);
+            });
+        TItem[] treeItemViewModels = await Task.WhenAll(tasks);
 
         if (missingParentIds is not null)
         {
@@ -230,8 +230,11 @@ protected virtual IEntitySlim[] GetSiblingEntities(
                 ordering: ItemOrdering)
             .ToArray();
 
-    protected virtual TItem[] MapTreeItemViewModels(Guid? parentKey, IEntitySlim[] entities)
-        => entities.Select(entity => MapTreeItemViewModel(parentKey, entity)).ToArray();
+    protected virtual async Task<TItem[]> MapTreeItemViewModelsAsync(Guid? parentKey, IEntitySlim[] entities)
+    {
+        IEnumerable<Task<TItem>> tasks = entities.Select(entity => MapTreeItemViewModelAsync(parentKey, entity));
+        return await Task.WhenAll(tasks);
+    }
 
     protected virtual async Task PopulateFlags(TItem[] treeItemViewModels)
     {
@@ -241,7 +244,7 @@ protected virtual async Task PopulateFlags(TItem[] treeItemViewModels)
         }
     }
 
-    protected virtual TItem MapTreeItemViewModel(Guid? parentKey, IEntitySlim entity)
+    protected virtual Task<TItem> MapTreeItemViewModelAsync(Guid? parentKey, IEntitySlim entity)
     {
         var viewModel = new TItem
         {
@@ -252,7 +255,7 @@ protected virtual TItem MapTreeItemViewModel(Guid? parentKey, IEntitySlim entity
                 : null,
         };
 
-        return viewModel;
+        return Task.FromResult(viewModel);
     }
 
     protected PagedViewModel<TItem> PagedViewModel(IEnumerable<TItem> treeItemViewModels, long totalItems)
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Tree/FolderTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Tree/FolderTreeControllerBase.cs
index 03e40a46e446..0ef244a9ac93 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Tree/FolderTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Tree/FolderTreeControllerBase.cs
@@ -122,9 +122,9 @@ protected override IEntitySlim[] GetSiblingEntities(Guid target, int before, int
             .ToArray();
     }
 
-    protected override TItem MapTreeItemViewModel(Guid? parentKey, IEntitySlim entity)
+    protected override async Task<TItem> MapTreeItemViewModelAsync(Guid? parentKey, IEntitySlim entity)
     {
-        TItem viewModel = base.MapTreeItemViewModel(parentKey, entity);
+        TItem viewModel = await base.MapTreeItemViewModelAsync(parentKey, entity);
 
         if (entity.NodeObjectType == _folderObjectTypeId)
         {
@@ -194,7 +194,7 @@ protected async Task<ActionResult<PagedViewModel<TItem>>> SearchTreeEntities(
         (IEntitySlim[] entities, long totalItems) =
             await FilterTreeEntities(itemSearchResult.Items.ToArray(), itemSearchResult.Total);
 
-        TItem[] treeItemViewModels = MapSearchTreeItemViewModels(entities);
+        TItem[] treeItemViewModels = await MapSearchTreeItemViewModelsAsync(entities);
 
         await PopulateFlags(treeItemViewModels);
 
@@ -203,8 +203,11 @@ protected async Task<ActionResult<PagedViewModel<TItem>>> SearchTreeEntities(
         return Ok(result);
     }
 
-    protected virtual TItem[] MapSearchTreeItemViewModels(IEntitySlim[] entities)
-        => entities.Select(entity => MapTreeItemViewModel(GetSearchResultParentKey(entity), entity)).ToArray();
+    protected virtual async Task<TItem[]> MapSearchTreeItemViewModelsAsync(IEntitySlim[] entities)
+    {
+        IEnumerable<Task<TItem>> tasks = entities.Select(entity => MapTreeItemViewModelAsync(GetSearchResultParentKey(entity), entity));
+        return await Task.WhenAll(tasks);
+    }
 
     private Guid? GetSearchResultParentKey(IEntitySlim entity)
     {
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Tree/NamedEntityTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Tree/NamedEntityTreeControllerBase.cs
index 3da3643d28f5..6fb28e3e2291 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Tree/NamedEntityTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Tree/NamedEntityTreeControllerBase.cs
@@ -19,9 +19,9 @@ protected NamedEntityTreeControllerBase(IEntityService entityService, FlagProvid
     {
     }
 
-    protected override TItem MapTreeItemViewModel(Guid? parentKey, IEntitySlim entity)
+    protected override async Task<TItem> MapTreeItemViewModelAsync(Guid? parentKey, IEntitySlim entity)
     {
-        TItem item = base.MapTreeItemViewModel(parentKey, entity);
+        TItem item = await base.MapTreeItemViewModelAsync(parentKey, entity);
         item.Name = entity.Name ?? string.Empty;
         return item;
     }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Tree/UserStartNodeFolderTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Tree/UserStartNodeFolderTreeControllerBase.cs
index 4075b8ad9713..87d69608e39a 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Tree/UserStartNodeFolderTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Tree/UserStartNodeFolderTreeControllerBase.cs
@@ -115,17 +115,17 @@ protected override IEntitySlim[] GetSiblingEntities(Guid target, int before, int
     }
 
     /// <inheritdoc />
-    protected override TItem[] MapTreeItemViewModels(Guid? parentKey, IEntitySlim[] entities)
+    protected override async Task<TItem[]> MapTreeItemViewModelsAsync(Guid? parentKey, IEntitySlim[] entities)
     {
         if (UserHasRootAccess() || IgnoreUserStartNodes())
         {
-            return base.MapTreeItemViewModels(parentKey, entities);
+            return await base.MapTreeItemViewModelsAsync(parentKey, entities);
         }
 
         // for users with no root access, only add items for the entities contained within the calculated access map.
         // the access map may contain entities that the user does not have direct access to, but need still to see,
         // because it has descendants that the user *does* have access to. these entities are added as "no access" items.
-        TItem[] treeItemViewModels = entities.Select(entity =>
+        IEnumerable<Task<TItem?>> tasks = entities.Select(async entity =>
             {
                 if (_accessMap.TryGetValue(entity.Key, out var hasAccess) is false)
                 {
@@ -136,9 +136,10 @@ protected override TItem[] MapTreeItemViewModels(Guid? parentKey, IEntitySlim[]
                 // direct access => return a regular item
                 // no direct access => return a "no access" item
                 return hasAccess
-                    ? MapTreeItemViewModel(parentKey, entity)
-                    : MapTreeItemViewModelAsNoAccess(parentKey, entity);
-            })
+                    ? await MapTreeItemViewModelAsync(parentKey, entity)
+                    : await MapTreeItemViewModelAsNoAccessAsync(parentKey, entity);
+            });
+        TItem[] treeItemViewModels = (await Task.WhenAll(tasks))
             .WhereNotNull()
             .ToArray();
 
@@ -154,8 +155,8 @@ protected override TItem[] MapTreeItemViewModels(Guid? parentKey, IEntitySlim[]
     /// <remarks>
     /// Subclasses should override this to set the appropriate "no access" flag on the view model.
     /// </remarks>
-    protected virtual TItem MapTreeItemViewModelAsNoAccess(Guid? parentKey, IEntitySlim entity)
-        => MapTreeItemViewModel(parentKey, entity);
+    protected virtual Task<TItem> MapTreeItemViewModelAsNoAccessAsync(Guid? parentKey, IEntitySlim entity)
+        => MapTreeItemViewModelAsync(parentKey, entity);
 
     private int[] UserStartNodeIds => field ??= GetUserStartNodeIds();
 
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/Tree/UserStartNodeTreeControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/Tree/UserStartNodeTreeControllerBase.cs
index 4b6f83b495b9..bd5dd57fa751 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/Tree/UserStartNodeTreeControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/Tree/UserStartNodeTreeControllerBase.cs
@@ -86,17 +86,17 @@ protected override IEntitySlim[] GetSiblingEntities(Guid target, int before, int
         return CalculateAccessMap(() => userAccessEntities, out _);
     }
 
-    protected override TItem[] MapTreeItemViewModels(Guid? parentKey, IEntitySlim[] entities)
+    protected override async Task<TItem[]> MapTreeItemViewModelsAsync(Guid? parentKey, IEntitySlim[] entities)
     {
         if (UserHasRootAccess() || IgnoreUserStartNodes())
         {
-            return base.MapTreeItemViewModels(parentKey, entities);
+            return await base.MapTreeItemViewModelsAsync(parentKey, entities);
         }
 
         // for users with no root access, only add items for the entities contained within the calculated access map.
         // the access map may contain entities that the user does not have direct access to, but need still to see,
         // because it has descendants that the user *does* have access to. these entities are added as "no access" items.
-        TItem[] contentTreeItemViewModels = entities.Select(entity =>
+        IEnumerable<Task<TItem?>> tasks = entities.Select(async entity =>
             {
                 if (_accessMap.TryGetValue(entity.Key, out var hasAccess) == false)
                 {
@@ -107,9 +107,10 @@ protected override TItem[] MapTreeItemViewModels(Guid? parentKey, IEntitySlim[]
                 // direct access => return a regular item
                 // no direct access => return a "no access" item
                 return hasAccess
-                    ? MapTreeItemViewModel(parentKey, entity)
-                    : MapTreeItemViewModelAsNoAccess(parentKey, entity);
-            })
+                    ? await MapTreeItemViewModelAsync(parentKey, entity)
+                    : await MapTreeItemViewModelAsNoAccessAsync(parentKey, entity);
+            });
+        TItem[] contentTreeItemViewModels = (await Task.WhenAll(tasks))
             .WhereNotNull()
             .ToArray();
 
@@ -138,9 +139,9 @@ private IEntitySlim[] CalculateAccessMap(Func<IEnumerable<UserAccessEntity>> get
         return entities;
     }
 
-    private TItem MapTreeItemViewModelAsNoAccess(Guid? parentKey, IEntitySlim entity)
+    private async Task<TItem> MapTreeItemViewModelAsNoAccessAsync(Guid? parentKey, IEntitySlim entity)
     {
-        TItem viewModel = MapTreeItemViewModel(parentKey, entity);
+        TItem viewModel = await MapTreeItemViewModelAsync(parentKey, entity);
         viewModel.NoAccess = true;
         return viewModel;
     }
diff --git a/src/Umbraco.Cms.Api.Management/Controllers/User/UserOrCurrentUserControllerBase.cs b/src/Umbraco.Cms.Api.Management/Controllers/User/UserOrCurrentUserControllerBase.cs
index dc5d40848371..729330c3256b 100644
--- a/src/Umbraco.Cms.Api.Management/Controllers/User/UserOrCurrentUserControllerBase.cs
+++ b/src/Umbraco.Cms.Api.Management/Controllers/User/UserOrCurrentUserControllerBase.cs
@@ -95,6 +95,10 @@ protected IActionResult UserOperationStatusResult(UserOperationStatus status, Er
                 .WithTitle("Media Start Node not found")
                 .WithDetail("Some of the provided media start nodes was not found.")
                 .Build()),
+            UserOperationStatus.ElementStartNodeNotFound => BadRequest(problemDetailsBuilder
+                .WithTitle("Element Start Node not found")
+                .WithDetail("Some of the provided element start nodes was not found.")
+                .Build()),
             UserOperationStatus.UserNotFound => NotFound(problemDetailsBuilder
                 .WithTitle("The user was not found")
                 .WithDetail("The specified user was not found.")
@@ -140,6 +144,10 @@ protected IActionResult UserOperationStatusResult(UserOperationStatus status, Er
                 .WithDetail("The target user type does not support this operation.")
                 .Build()),
             UserOperationStatus.Forbidden => Forbidden(),
+            UserOperationStatus.ApplicationUrlNotConfigured => BadRequest(problemDetailsBuilder
+                .WithTitle("Application URL not configured")
+                .WithDetail("The application URL is not configured. Set Umbraco:CMS:WebRouting:UmbracoApplicationUrl in configuration, or change Umbraco:CMS:WebRouting:ApplicationUrlDetection to 'FirstRequest' or 'EveryRequest'.")
+                .Build()),
             _ => StatusCode(StatusCodes.Status500InternalServerError, problemDetailsBuilder
                 .WithTitle("Unknown user operation status.")
                 .Build()),
diff --git a/src/Umbraco.Cms.Api.Management/DependencyInjection/InstallerBuilderExtensions.cs b/src/Umbraco.Cms.Api.Management/DependencyInjection/InstallerBuilderExtensions.cs
index 6f846bcfdd0a..1f7694cfb007 100644
--- a/src/Umbraco.Cms.Api.Management/DependencyInjection/InstallerBuilderExtensions.cs
+++ b/src/Umbraco.Cms.Api.Management/DependencyInjection/InstallerBuilderExtensions.cs
@@ -22,7 +22,7 @@ internal static IUmbracoBuilder AddInstaller(this IUmbracoBuilder builder)
     {
         IServiceCollection services = builder.Services;
 
-        services.AddTransient<IUserSettingsFactory, UserSettingsFactory>();
+        services.AddTransient<IUserSettingsFactory>(sp => ActivatorUtilities.CreateInstance<UserSettingsFactory>(sp));
         services.AddTransient<IInstallSettingsFactory, InstallSettingsFactory>();
         services.AddTransient<IDatabaseSettingsFactory, DatabaseSettingsFactory>();
 
diff --git a/src/Umbraco.Cms.Api.Management/DependencyInjection/PasswordBuilderExtensions.cs b/src/Umbraco.Cms.Api.Management/DependencyInjection/PasswordBuilderExtensions.cs
index 3f1fc28e01c2..f4226b29b18b 100644
--- a/src/Umbraco.Cms.Api.Management/DependencyInjection/PasswordBuilderExtensions.cs
+++ b/src/Umbraco.Cms.Api.Management/DependencyInjection/PasswordBuilderExtensions.cs
@@ -1,4 +1,4 @@
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
 using Umbraco.Cms.Api.Management.Factories;
 using Umbraco.Cms.Core.DependencyInjection;
 
diff --git a/src/Umbraco.Cms.Api.Management/DependencyInjection/UmbracoBuilder.Collections.cs b/src/Umbraco.Cms.Api.Management/DependencyInjection/UmbracoBuilder.Collections.cs
index 89c4a85f0bf4..5184aa2ba481 100644
--- a/src/Umbraco.Cms.Api.Management/DependencyInjection/UmbracoBuilder.Collections.cs
+++ b/src/Umbraco.Cms.Api.Management/DependencyInjection/UmbracoBuilder.Collections.cs
@@ -11,7 +11,8 @@ public static partial class UmbracoBuilderExtensions
         internal static void AddCollectionBuilders(this IUmbracoBuilder builder)
         {
             builder.FlagProviders()
-                .Append<HasScheduleFlagProvider>()
+                .Append<HasDocumentScheduleFlagProvider>()
+                .Append<HasElementScheduleFlagProvider>()
                 .Append<IsProtectedFlagProvider>()
                 .Append<HasPendingChangesFlagProvider>()
                 .Append<HasCollectionFlagProvider>();
diff --git a/src/Umbraco.Cms.Api.Management/Factories/DocumentPresentationFactory.cs b/src/Umbraco.Cms.Api.Management/Factories/DocumentPresentationFactory.cs
index ae0a80229d64..46e328bca53b 100644
--- a/src/Umbraco.Cms.Api.Management/Factories/DocumentPresentationFactory.cs
+++ b/src/Umbraco.Cms.Api.Management/Factories/DocumentPresentationFactory.cs
@@ -1,4 +1,3 @@
-using Umbraco.Cms.Api.Management.Mapping.Content;
 using Umbraco.Cms.Api.Management.Services.Flags;
 using Umbraco.Cms.Api.Management.ViewModels;
 using Umbraco.Cms.Api.Management.ViewModels.Document;
@@ -12,25 +11,23 @@
 using Umbraco.Cms.Core.Models.Entities;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Services.OperationStatus;
-using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Api.Management.Factories;
 
-internal sealed class DocumentPresentationFactory : IDocumentPresentationFactory
+/// <inheritdoc cref="IDocumentPresentationFactory" />
+internal sealed class DocumentPresentationFactory
+    : PublishableContentPresentationFactoryBase<IDocumentEntitySlim, DocumentVariantItemResponseModel>,
+      IDocumentPresentationFactory
 {
-    private readonly IUmbracoMapper _umbracoMapper;
-    private readonly IDocumentUrlFactory _documentUrlFactory;
     private readonly ITemplateService _templateService;
     private readonly IPublicAccessService _publicAccessService;
     private readonly TimeProvider _timeProvider;
     private readonly IIdKeyMap _idKeyMap;
-    private readonly FlagProviderCollection _flagProviderCollection;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="DocumentPresentationFactory"/> class.
     /// </summary>
     /// <param name="umbracoMapper">The mapper used to map between Umbraco models.</param>
-    /// <param name="documentUrlFactory">Factory for generating URLs for documents.</param>
     /// <param name="templateService">Service for managing and retrieving templates.</param>
     /// <param name="publicAccessService">Service for handling public access and permissions.</param>
     /// <param name="timeProvider">Provider for obtaining the current time.</param>
@@ -38,36 +35,26 @@ internal sealed class DocumentPresentationFactory : IDocumentPresentationFactory
     /// <param name="flagProviderCollection">Collection of providers for document flags.</param>
     public DocumentPresentationFactory(
         IUmbracoMapper umbracoMapper,
-        IDocumentUrlFactory documentUrlFactory,
         ITemplateService templateService,
         IPublicAccessService publicAccessService,
         TimeProvider timeProvider,
         IIdKeyMap idKeyMap,
         FlagProviderCollection flagProviderCollection)
+        : base(umbracoMapper, flagProviderCollection)
     {
-        _umbracoMapper = umbracoMapper;
-        _documentUrlFactory = documentUrlFactory;
         _templateService = templateService;
         _publicAccessService = publicAccessService;
         _timeProvider = timeProvider;
         _idKeyMap = idKeyMap;
-        _flagProviderCollection = flagProviderCollection;
     }
 
-    /// <summary>
-    /// Asynchronously creates a <see cref="PublishedDocumentResponseModel"/> from the specified <see cref="IContent"/> instance.
-    /// </summary>
-    /// <param name="content">The content item from which to generate the published document response model.</param>
-    /// <returns>
-    /// A task representing the asynchronous operation. The result contains the generated <see cref="PublishedDocumentResponseModel"/>,
-    /// including template reference information if available.
-    /// </returns>
+    /// <inheritdoc/>
     public async Task<PublishedDocumentResponseModel> CreatePublishedResponseModelAsync(IContent content)
     {
-        PublishedDocumentResponseModel responseModel = _umbracoMapper.Map<PublishedDocumentResponseModel>(content)!;
+        PublishedDocumentResponseModel responseModel = UmbracoMapper.Map<PublishedDocumentResponseModel>(content)!;
 
         Guid? templateKey = content.PublishTemplateId.HasValue
-            ? _templateService.GetAsync(content.PublishTemplateId.Value).Result?.Key
+            ? (await _templateService.GetAsync(content.PublishTemplateId.Value))?.Key
             : null;
 
         responseModel.Template = templateKey.HasValue
@@ -77,20 +64,14 @@ public async Task<PublishedDocumentResponseModel> CreatePublishedResponseModelAs
         return responseModel;
     }
 
-    /// <summary>
-    /// Asynchronously creates a <see cref="DocumentResponseModel"/> from the specified <see cref="IContent"/> and <see cref="ContentScheduleCollection"/>.
-    /// Maps the content and schedule to the response model, and if the content has an associated template, includes its reference in the result.
-    /// </summary>
-    /// <param name="content">The content item to map to the response model.</param>
-    /// <param name="schedule">The collection of content schedules to include in the response model.</param>
-    /// <returns>A task representing the asynchronous operation. The task result contains the constructed <see cref="DocumentResponseModel"/>, including template reference if applicable.</returns>
+    /// <inheritdoc/>
     public async Task<DocumentResponseModel> CreateResponseModelAsync(IContent content, ContentScheduleCollection schedule)
     {
-        DocumentResponseModel responseModel = _umbracoMapper.Map<DocumentResponseModel>(content)!;
-        _umbracoMapper.Map(schedule, responseModel);
+        DocumentResponseModel responseModel = UmbracoMapper.Map<DocumentResponseModel>(content)!;
+        UmbracoMapper.Map(schedule, responseModel);
 
         Guid? templateKey = content.TemplateId.HasValue
-            ? _templateService.GetAsync(content.TemplateId.Value).Result?.Key
+            ? (await _templateService.GetAsync(content.TemplateId.Value))?.Key
             : null;
 
         responseModel.Template = templateKey.HasValue
@@ -100,15 +81,13 @@ public async Task<DocumentResponseModel> CreateResponseModelAsync(IContent conte
         return responseModel;
     }
 
-    /// <summary>
-    /// Creates a <see cref="DocumentItemResponseModel"/> from the specified <see cref="IDocumentEntitySlim"/> entity.
-    /// Populates the response model with the document's key properties, including parent reference, trashed status, protection status, document type, variants, and additional flags.
-    /// </summary>
-    /// <param name="entity">The document entity to create the response model from.</param>
-    /// <returns>
-    /// A <see cref="DocumentItemResponseModel"/> representing the document entity, with populated metadata and references.
-    /// </returns>
+    /// <inheritdoc/>
+    [Obsolete("Use CreateItemResponseModelAsync instead. Scheduled for removal in Umbraco 19.")]
     public DocumentItemResponseModel CreateItemResponseModel(IDocumentEntitySlim entity)
+        => CreateItemResponseModelAsync(entity).GetAwaiter().GetResult();
+
+    /// <inheritdoc/>
+    public async Task<DocumentItemResponseModel> CreateItemResponseModelAsync(IDocumentEntitySlim entity)
     {
         Attempt<Guid> parentKeyAttempt = _idKeyMap.GetKeyForId(entity.ParentId, UmbracoObjectTypes.Document);
 
@@ -118,82 +97,30 @@ public DocumentItemResponseModel CreateItemResponseModel(IDocumentEntitySlim ent
             IsTrashed = entity.Trashed,
             Parent = parentKeyAttempt.Success ? new ReferenceByIdModel { Id = parentKeyAttempt.Result } : null,
             HasChildren = entity.HasChildren,
+            IsProtected = _publicAccessService.IsProtected(entity.Path),
+            DocumentType = CreateDocumentTypeReferenceResponseModel(entity),
+            Variants = await CreateVariantsItemResponseModelsAsync(entity),
         };
 
-        responseModel.IsProtected = _publicAccessService.IsProtected(entity.Path);
-
-        responseModel.DocumentType = _umbracoMapper.Map<DocumentTypeReferenceResponseModel>(entity)!;
-
-        responseModel.Variants = CreateVariantsItemResponseModels(entity);
-
-        PopulateFlagsOnDocuments(responseModel);
+        await PopulateFlagsAsync(responseModel);
 
         return responseModel;
     }
 
+    /// <inheritdoc/>
     public DocumentBlueprintItemResponseModel CreateBlueprintItemResponseModel(IDocumentEntitySlim entity)
     {
         var responseModel = new DocumentBlueprintItemResponseModel
         {
             Id = entity.Key,
             Name = entity.Name ?? string.Empty,
+            DocumentType = UmbracoMapper.Map<DocumentTypeReferenceResponseModel>(entity)!,
         };
 
-        responseModel.DocumentType = _umbracoMapper.Map<DocumentTypeReferenceResponseModel>(entity)!;
-
         return responseModel;
     }
 
-    /// <summary>
-    /// Generates a collection of <see cref="DocumentVariantItemResponseModel"/> objects representing each variant (culture) of the specified document entity.
-    /// </summary>
-    /// <param name="entity">The document entity for which to generate variant response models.</param>
-    /// <returns>An <see cref="IEnumerable{DocumentVariantItemResponseModel}"/> containing a response model for each variant of the document.</returns>
-    public IEnumerable<DocumentVariantItemResponseModel> CreateVariantsItemResponseModels(IDocumentEntitySlim entity)
-    {
-        if (entity.Variations.VariesByCulture() is false)
-        {
-            var model = new DocumentVariantItemResponseModel()
-            {
-                Name = entity.Name ?? string.Empty,
-                State = DocumentVariantStateHelper.GetState(entity, null),
-                Culture = null,
-            };
-
-            PopulateFlagsOnVariants(model);
-            yield return model;
-            yield break;
-        }
-
-        foreach (KeyValuePair<string, string> cultureNamePair in entity.CultureNames)
-        {
-            var model = new DocumentVariantItemResponseModel()
-            {
-                Name = cultureNamePair.Value,
-                Culture = cultureNamePair.Key,
-                State = DocumentVariantStateHelper.GetState(entity, cultureNamePair.Key)
-            };
-
-            PopulateFlagsOnVariants(model);
-            yield return model;
-        }
-    }
-
-    /// <summary>
-    /// Creates a <see cref="DocumentTypeReferenceResponseModel"/> from the given <see cref="IDocumentEntitySlim"/> entity.
-    /// </summary>
-    /// <param name="entity">The document entity to map.</param>
-    /// <returns>A mapped <see cref="DocumentTypeReferenceResponseModel"/> instance.</returns>
-    public DocumentTypeReferenceResponseModel CreateDocumentTypeReferenceResponseModel(IDocumentEntitySlim entity)
-        => _umbracoMapper.Map<DocumentTypeReferenceResponseModel>(entity)!;
-
-    /// <summary>
-    /// Creates a list of <see cref="Umbraco.Cms.Api.Management.Models.Content.CulturePublishScheduleModel"/> instances from the specified <see cref="Umbraco.Cms.Api.Management.Models.Content.PublishDocumentRequestModel"/>.
-    /// Validates the publish and unpublish times for each culture's schedule, ensuring they are in the future and that unpublish times are after publish times.
-    /// Returns an <see cref="Umbraco.Cms.Core.Models.Attempt"/> containing the resulting list and a <see cref="Umbraco.Cms.Api.Management.Models.Content.ContentPublishingOperationStatus"/> indicating the outcome of the validation.
-    /// </summary>
-    /// <param name="requestModel">The request model containing culture-specific publish schedules to process.</param>
-    /// <returns>An <see cref="Umbraco.Cms.Core.Models.Attempt"/> with a list of <see cref="Umbraco.Cms.Api.Management.Models.Content.CulturePublishScheduleModel"/> and the validation status.</returns>
+    /// <inheritdoc/>
     public Attempt<List<CulturePublishScheduleModel>, ContentPublishingOperationStatus> CreateCulturePublishScheduleModels(PublishDocumentRequestModel requestModel)
     {
         var model = new List<CulturePublishScheduleModel>();
@@ -241,19 +168,10 @@ public Attempt<List<CulturePublishScheduleModel>, ContentPublishingOperationStat
         return Attempt.SucceedWithStatus(ContentPublishingOperationStatus.Success, model);
     }
 
-    private void PopulateFlagsOnDocuments(DocumentItemResponseModel model)
-    {
-        foreach (IFlagProvider signProvider in _flagProviderCollection.Where(x => x.CanProvideFlags<DocumentItemResponseModel>()))
-        {
-            signProvider.PopulateFlagsAsync([model]).GetAwaiter().GetResult();
-        }
-    }
-
-    private void PopulateFlagsOnVariants(DocumentVariantItemResponseModel model)
-    {
-        foreach (IFlagProvider signProvider in _flagProviderCollection.Where(x => x.CanProvideFlags<DocumentVariantItemResponseModel>()))
-        {
-            signProvider.PopulateFlagsAsync([model]).GetAwaiter().GetResult();
-        }
-    }
+    /// <inheritdoc/>
+    protected override DocumentVariantItemResponseModel CreateVariantItemResponseModel(
+        string name,
+        DocumentVariantState state,
+        string? culture)
+        => new() { Name = name, State = state, Culture = culture };
 }
diff --git a/src/Umbraco.Cms.Api.Management/Factories/ElementPresentationFactory.cs b/src/Umbraco.Cms.Api.Management/Factories/ElementPresentationFactory.cs
index 337e3452ade0..66687e7dcd9f 100644
--- a/src/Umbraco.Cms.Api.Management/Factories/ElementPresentationFactory.cs
+++ b/src/Umbraco.Cms.Api.Management/Factories/ElementPresentationFactory.cs
@@ -1,6 +1,6 @@
-using Umbraco.Cms.Api.Management.Mapping.Content;
+using Umbraco.Cms.Api.Management.Services.Flags;
 using Umbraco.Cms.Api.Management.ViewModels;
-using Umbraco.Cms.Api.Management.ViewModels.DocumentType;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
 using Umbraco.Cms.Api.Management.ViewModels.Element;
 using Umbraco.Cms.Api.Management.ViewModels.Element.Item;
 using Umbraco.Cms.Core;
@@ -8,17 +8,14 @@
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Entities;
 using Umbraco.Cms.Core.Services;
-using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Api.Management.Factories;
 
-// TODO ELEMENTS: lots of code here was duplicated from DocumentPresentationFactory - abstract and refactor
-/// <summary>
-/// Factory for creating element presentation models from domain models.
-/// </summary>
-public class ElementPresentationFactory : IElementPresentationFactory
+/// <inheritdoc cref="IElementPresentationFactory" />
+internal sealed class ElementPresentationFactory
+    : PublishableContentPresentationFactoryBase<IElementEntitySlim, ElementVariantItemResponseModel>,
+      IElementPresentationFactory
 {
-    private readonly IUmbracoMapper _umbracoMapper;
     private readonly IIdKeyMap _idKeyMap;
 
     /// <summary>
@@ -26,23 +23,25 @@ public class ElementPresentationFactory : IElementPresentationFactory
     /// </summary>
     /// <param name="umbracoMapper">The mapper used to map between Umbraco models.</param>
     /// <param name="idKeyMap">Service for mapping between IDs and keys.</param>
-    public ElementPresentationFactory(IUmbracoMapper umbracoMapper, IIdKeyMap idKeyMap)
-    {
-        _umbracoMapper = umbracoMapper;
+    /// <param name="flagProviderCollection">Collection of providers for document flags.</param>
+    public ElementPresentationFactory(
+        IUmbracoMapper umbracoMapper,
+        IIdKeyMap idKeyMap,
+        FlagProviderCollection flagProviderCollection)
+        : base(umbracoMapper, flagProviderCollection) =>
         _idKeyMap = idKeyMap;
-    }
 
     /// <inheritdoc />
     public ElementResponseModel CreateResponseModel(IElement element, ContentScheduleCollection schedule)
     {
-        ElementResponseModel responseModel = _umbracoMapper.Map<ElementResponseModel>(element)!;
-        _umbracoMapper.Map(schedule, responseModel);
+        ElementResponseModel responseModel = UmbracoMapper.Map<ElementResponseModel>(element)!;
+        UmbracoMapper.Map(schedule, responseModel);
 
         return responseModel;
     }
 
     /// <inheritdoc />
-    public ElementItemResponseModel CreateItemResponseModel(IElementEntitySlim entity)
+    public async Task<ElementItemResponseModel> CreateItemResponseModelAsync(IElementEntitySlim entity)
     {
         Attempt<Guid> parentKeyAttempt = _idKeyMap.GetKeyForId(entity.ParentId, UmbracoObjectTypes.ElementContainer);
 
@@ -51,45 +50,19 @@ public ElementItemResponseModel CreateItemResponseModel(IElementEntitySlim entit
             Id = entity.Key,
             Parent = parentKeyAttempt.Success ? new ReferenceByIdModel { Id = parentKeyAttempt.Result } : null,
             HasChildren = entity.HasChildren,
+            DocumentType = CreateDocumentTypeReferenceResponseModel(entity),
+            Variants = await CreateVariantsItemResponseModelsAsync(entity),
         };
 
-        responseModel.DocumentType = _umbracoMapper.Map<DocumentTypeReferenceResponseModel>(entity)!;
-
-        responseModel.Variants = CreateVariantsItemResponseModels(entity);
+        await PopulateFlagsAsync(responseModel);
 
         return responseModel;
     }
 
     /// <inheritdoc />
-    public IEnumerable<ElementVariantItemResponseModel> CreateVariantsItemResponseModels(IElementEntitySlim entity)
-    {
-        if (entity.Variations.VariesByCulture() is false)
-        {
-            var model = new ElementVariantItemResponseModel()
-            {
-                Name = entity.Name ?? string.Empty,
-                State = DocumentVariantStateHelper.GetState(entity, null),
-                Culture = null,
-            };
-
-            yield return model;
-            yield break;
-        }
-
-        foreach (KeyValuePair<string, string> cultureNamePair in entity.CultureNames)
-        {
-            var model = new ElementVariantItemResponseModel()
-            {
-                Name = cultureNamePair.Value,
-                Culture = cultureNamePair.Key,
-                State = DocumentVariantStateHelper.GetState(entity, cultureNamePair.Key)
-            };
-
-            yield return model;
-        }
-    }
-
-    /// <inheritdoc />
-    public DocumentTypeReferenceResponseModel CreateDocumentTypeReferenceResponseModel(IElementEntitySlim entity)
-        => _umbracoMapper.Map<DocumentTypeReferenceResponseModel>(entity)!;
+    protected override ElementVariantItemResponseModel CreateVariantItemResponseModel(
+        string name,
+        DocumentVariantState state,
+        string? culture)
+        => new() { Name = name, State = state, Culture = culture };
 }
diff --git a/src/Umbraco.Cms.Api.Management/Factories/IDocumentPresentationFactory.cs b/src/Umbraco.Cms.Api.Management/Factories/IDocumentPresentationFactory.cs
index 1e38dd52e493..afefca421594 100644
--- a/src/Umbraco.Cms.Api.Management/Factories/IDocumentPresentationFactory.cs
+++ b/src/Umbraco.Cms.Api.Management/Factories/IDocumentPresentationFactory.cs
@@ -31,11 +31,13 @@ public interface IDocumentPresentationFactory
     /// <param name="schedule">The schedule collection associated with the content.</param>
     /// <returns>A task that represents the asynchronous operation. The task result contains the document response model.</returns>
     Task<DocumentResponseModel> CreateResponseModelAsync(IContent content, ContentScheduleCollection schedule);
+
     /// <summary>
     /// Creates a response model for a document item based on the provided entity.
     /// </summary>
     /// <param name="entity">The document entity to create the response model from.</param>
     /// <returns>A <see cref="DocumentItemResponseModel"/> representing the document item.</returns>
+    [Obsolete("Use CreateItemResponseModelAsync instead. Scheduled for removal in Umbraco 19.")]
     DocumentItemResponseModel CreateItemResponseModel(IDocumentEntitySlim entity);
 
     /// <summary>
@@ -50,6 +52,7 @@ public interface IDocumentPresentationFactory
     /// </summary>
     /// <param name="entity">The document entity to create variant response models for.</param>
     /// <returns>An enumerable of <see cref="DocumentVariantItemResponseModel"/> representing the document variants.</returns>
+    [Obsolete("Use CreateVariantsItemResponseModelsAsync instead. Scheduled for removal in Umbraco 19.")]
     IEnumerable<DocumentVariantItemResponseModel> CreateVariantsItemResponseModels(IDocumentEntitySlim entity);
 
     /// <summary>
@@ -75,11 +78,11 @@ Attempt<List<CulturePublishScheduleModel>, ContentPublishingOperationStatus> Cre
         {
             if (cultureAndScheduleRequestModel.Schedule is null)
             {
-                model.Add(new CulturePublishScheduleModel
-                {
-                    Culture = cultureAndScheduleRequestModel.Culture
-                              ?? Constants.System.InvariantCulture
-                });
+                model.Add(
+                    new CulturePublishScheduleModel
+                    {
+                        Culture = cultureAndScheduleRequestModel.Culture ?? Constants.System.InvariantCulture,
+                    });
                 continue;
             }
 
@@ -100,17 +103,40 @@ Attempt<List<CulturePublishScheduleModel>, ContentPublishingOperationStatus> Cre
                 return Attempt.FailWithStatus(ContentPublishingOperationStatus.UnpublishTimeNeedsToBeAfterPublishTime, model);
             }
 
-            model.Add(new CulturePublishScheduleModel
-            {
-                Culture = cultureAndScheduleRequestModel.Culture,
-                Schedule = new ContentScheduleModel
+            model.Add(
+                new CulturePublishScheduleModel
                 {
-                    PublishDate = cultureAndScheduleRequestModel.Schedule.PublishTime,
-                    UnpublishDate = cultureAndScheduleRequestModel.Schedule.UnpublishTime,
-                },
-            });
+                    Culture = cultureAndScheduleRequestModel.Culture,
+                    Schedule = new ContentScheduleModel
+                    {
+                        PublishDate = cultureAndScheduleRequestModel.Schedule.PublishTime,
+                        UnpublishDate = cultureAndScheduleRequestModel.Schedule.UnpublishTime,
+                    },
+                });
         }
 
         return Attempt.SucceedWithStatus(ContentPublishingOperationStatus.Success, model);
     }
+
+    /// <summary>
+    /// Asynchronously creates a response model for a document item based on the provided entity.
+    /// </summary>
+    /// <param name="entity">The document entity to create the response model from.</param>
+    /// <returns>A task that represents the asynchronous operation. The task result contains a <see cref="DocumentItemResponseModel"/> representing the document item.</returns>
+    // TODO (V19): Remove the default implementation when CreateItemResponseModel is removed.
+    Task<DocumentItemResponseModel> CreateItemResponseModelAsync(IDocumentEntitySlim entity)
+#pragma warning disable CS0618 // Type or member is obsolete
+        => Task.FromResult(CreateItemResponseModel(entity));
+#pragma warning restore CS0618 // Type or member is obsolete
+
+    /// <summary>
+    /// Asynchronously creates a collection of <see cref="DocumentVariantItemResponseModel"/> instances representing the variants of the specified document entity.
+    /// </summary>
+    /// <param name="entity">The document entity to create variant response models for.</param>
+    /// <returns>A task that represents the asynchronous operation. The task result contains an enumerable of <see cref="DocumentVariantItemResponseModel"/> representing the document variants.</returns>
+    // TODO (V19): Remove the default implementation when CreateVariantsItemResponseModels is removed.
+    Task<IEnumerable<DocumentVariantItemResponseModel>> CreateVariantsItemResponseModelsAsync(IDocumentEntitySlim entity)
+#pragma warning disable CS0618 // Type or member is obsolete
+        => Task.FromResult(CreateVariantsItemResponseModels(entity));
+#pragma warning restore CS0618 // Type or member is obsolete
 }
diff --git a/src/Umbraco.Cms.Api.Management/Factories/IElementPresentationFactory.cs b/src/Umbraco.Cms.Api.Management/Factories/IElementPresentationFactory.cs
index 13e073682444..b1ad8c5594c7 100644
--- a/src/Umbraco.Cms.Api.Management/Factories/IElementPresentationFactory.cs
+++ b/src/Umbraco.Cms.Api.Management/Factories/IElementPresentationFactory.cs
@@ -1,4 +1,4 @@
-using Umbraco.Cms.Api.Management.ViewModels.DocumentType;
+using Umbraco.Cms.Api.Management.ViewModels.DocumentType;
 using Umbraco.Cms.Api.Management.ViewModels.Element;
 using Umbraco.Cms.Api.Management.ViewModels.Element.Item;
 using Umbraco.Cms.Core.Models;
@@ -24,14 +24,14 @@ public interface IElementPresentationFactory
     /// </summary>
     /// <param name="entity">The element entity to create the response model from.</param>
     /// <returns>An <see cref="ElementItemResponseModel"/> representing the element item.</returns>
-    ElementItemResponseModel CreateItemResponseModel(IElementEntitySlim entity);
+    Task<ElementItemResponseModel> CreateItemResponseModelAsync(IElementEntitySlim entity);
 
     /// <summary>
     /// Creates a collection of <see cref="ElementVariantItemResponseModel"/> instances representing the variants of the specified element entity.
     /// </summary>
     /// <param name="entity">The element entity to create variant response models for.</param>
     /// <returns>An enumerable of <see cref="ElementVariantItemResponseModel"/> representing the element variants.</returns>
-    IEnumerable<ElementVariantItemResponseModel> CreateVariantsItemResponseModels(IElementEntitySlim entity);
+    Task<IEnumerable<ElementVariantItemResponseModel>> CreateVariantsItemResponseModelsAsync(IElementEntitySlim entity);
 
     /// <summary>
     /// Creates a <see cref="DocumentTypeReferenceResponseModel"/> from the given <see cref="IElementEntitySlim"/> entity.
diff --git a/src/Umbraco.Cms.Api.Management/Factories/IPublicAccessPresentationFactory.cs b/src/Umbraco.Cms.Api.Management/Factories/IPublicAccessPresentationFactory.cs
index 04b236320d44..dc390da0a274 100644
--- a/src/Umbraco.Cms.Api.Management/Factories/IPublicAccessPresentationFactory.cs
+++ b/src/Umbraco.Cms.Api.Management/Factories/IPublicAccessPresentationFactory.cs
@@ -20,11 +20,7 @@ public interface IPublicAccessPresentationFactory
     /// Determines whether the entry is inherited from an ancestor by comparing the entry's protected node key against
     /// <paramref name="contentKey"/>.
     /// </remarks>
-    // TODO (V18): Remove the default implementation.
-    Attempt<PublicAccessResponseModel?, PublicAccessOperationStatus> CreatePublicAccessResponseModel(PublicAccessEntry entry, Guid contentKey)
-#pragma warning disable CS0618 // Type or member is obsolete
-        => CreatePublicAccessResponseModel(entry);
-#pragma warning restore CS0618 // Type or member is obsolete
+    Attempt<PublicAccessResponseModel?, PublicAccessOperationStatus> CreatePublicAccessResponseModel(PublicAccessEntry entry, Guid contentKey);
 
     /// <summary>
     /// Creates a <see cref="PublicAccessResponseModel"/> from a <see cref="PublicAccessEntry"/>.
diff --git a/src/Umbraco.Cms.Api.Management/Factories/IndexPresentationFactory.cs b/src/Umbraco.Cms.Api.Management/Factories/IndexPresentationFactory.cs
index 039aa9983cb6..59ad9ed1b93b 100644
--- a/src/Umbraco.Cms.Api.Management/Factories/IndexPresentationFactory.cs
+++ b/src/Umbraco.Cms.Api.Management/Factories/IndexPresentationFactory.cs
@@ -47,6 +47,7 @@ public IndexResponseModel Create(IIndex index)
     public async Task<IndexResponseModel> CreateAsync(IIndex index)
     {
         var isCorrupt = !TryGetSearcherName(index, out var searcherName);
+        var uniqueKeyFieldName = (index as IUmbracoIndex)?.UniqueKeyFieldName;
 
         if (await _indexingRebuilderService.IsRebuildingAsync(index.Name))
         {
@@ -60,6 +61,7 @@ public async Task<IndexResponseModel> CreateAsync(IIndex index)
                 SearcherName = searcherName,
                 DocumentCount = 0,
                 FieldCount = 0,
+                UniqueKeyFieldName = uniqueKeyFieldName,
             };
         }
 
@@ -107,6 +109,7 @@ public async Task<IndexResponseModel> CreateAsync(IIndex index)
             DocumentCount = documentCount,
             FieldCount = fieldNameCount,
             ProviderProperties = properties,
+            UniqueKeyFieldName = uniqueKeyFieldName,
         };
 
         return indexerModel;
diff --git a/src/Umbraco.Cms.Api.Management/Factories/PasswordConfigurationPresentationFactory.cs b/src/Umbraco.Cms.Api.Management/Factories/PasswordConfigurationPresentationFactory.cs
index 0bce53c2fbe4..dd374af428eb 100644
--- a/src/Umbraco.Cms.Api.Management/Factories/PasswordConfigurationPresentationFactory.cs
+++ b/src/Umbraco.Cms.Api.Management/Factories/PasswordConfigurationPresentationFactory.cs
@@ -1,6 +1,8 @@
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Umbraco.Cms.Api.Management.ViewModels.Security;
 using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.DependencyInjection;
 
 namespace Umbraco.Cms.Api.Management.Factories;
 
@@ -9,21 +11,39 @@ namespace Umbraco.Cms.Api.Management.Factories;
 /// </summary>
 public class PasswordConfigurationPresentationFactory : IPasswordConfigurationPresentationFactory
 {
-    private readonly UserPasswordConfigurationSettings _userPasswordConfigurationSettings;
+    private readonly SecuritySettings _securitySettings;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PasswordConfigurationPresentationFactory"/> class.
+    /// </summary>
+    /// <param name="securitySettings">An <see cref="IOptionsSnapshot{T}"/> containing the current <see cref="SecuritySettings"/> for user password configuration.</param>
+    public PasswordConfigurationPresentationFactory(IOptionsSnapshot<SecuritySettings> securitySettings)
+        => _securitySettings = securitySettings.Value;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PasswordConfigurationPresentationFactory"/> class.
     /// </summary>
     /// <param name="userPasswordConfigurationSettings">An <see cref="IOptionsSnapshot{T}"/> containing the current <see cref="UserPasswordConfigurationSettings"/> for user password configuration.</param>
-    public PasswordConfigurationPresentationFactory(IOptionsSnapshot<UserPasswordConfigurationSettings> userPasswordConfigurationSettings) => _userPasswordConfigurationSettings = userPasswordConfigurationSettings.Value;
+    [Obsolete("Use the constructor that accepts IOptionsSnapshot<SecuritySettings> instead. Scheduled for removal in Umbraco 19.")]
+    public PasswordConfigurationPresentationFactory(IOptionsSnapshot<UserPasswordConfigurationSettings> userPasswordConfigurationSettings)
+        : this(StaticServiceProvider.Instance.GetRequiredService<IOptionsSnapshot<SecuritySettings>>())
+    {
+    }
+
+    // This is just here to resolve an ambiguous constructor.
+    [Obsolete("Use the constructor that accepts IOptionsSnapshot<SecuritySettings> instead. Scheduled for removal in Umbraco 19.")]
+    public PasswordConfigurationPresentationFactory(IOptionsSnapshot<SecuritySettings> securitySettings, IOptionsSnapshot<UserPasswordConfigurationSettings> _)
+        : this(securitySettings)
+    {
+    }
 
     public PasswordConfigurationResponseModel CreatePasswordConfigurationResponseModel() =>
         new()
         {
-            MinimumPasswordLength = _userPasswordConfigurationSettings.RequiredLength,
-            RequireNonLetterOrDigit = _userPasswordConfigurationSettings.RequireNonLetterOrDigit,
-            RequireDigit = _userPasswordConfigurationSettings.RequireDigit,
-            RequireLowercase = _userPasswordConfigurationSettings.RequireLowercase,
-            RequireUppercase = _userPasswordConfigurationSettings.RequireUppercase,
+            MinimumPasswordLength = _securitySettings.UserPassword.RequiredLength,
+            RequireNonLetterOrDigit = _securitySettings.UserPassword.RequireNonLetterOrDigit,
+            RequireDigit = _securitySettings.UserPassword.RequireDigit,
+            RequireLowercase = _securitySettings.UserPassword.RequireLowercase,
+            RequireUppercase = _securitySettings.UserPassword.RequireUppercase,
         };
 }
diff --git a/src/Umbraco.Cms.Api.Management/Factories/PublishableContentPresentationFactoryBase.cs b/src/Umbraco.Cms.Api.Management/Factories/PublishableContentPresentationFactoryBase.cs
new file mode 100644
index 000000000000..74a77451151a
--- /dev/null
+++ b/src/Umbraco.Cms.Api.Management/Factories/PublishableContentPresentationFactoryBase.cs
@@ -0,0 +1,124 @@
+using Umbraco.Cms.Api.Management.Mapping.Content;
+using Umbraco.Cms.Api.Management.Services.Flags;
+using Umbraco.Cms.Api.Management.ViewModels;
+using Umbraco.Cms.Api.Management.ViewModels.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Api.Management.ViewModels.DocumentType;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Factories;
+
+/// <summary>
+/// Base class for presentation factories that create response models for publishable content entities (documents and elements).
+/// </summary>
+/// <typeparam name="TEntity">The publishable content entity type.</typeparam>
+/// <typeparam name="TVariantItemResponseModel">The variant item response model type.</typeparam>
+internal abstract class PublishableContentPresentationFactoryBase<TEntity, TVariantItemResponseModel>
+    where TEntity : IPublishableContentEntitySlim
+    where TVariantItemResponseModel : PublishableVariantItemResponseModelBase
+{
+    private readonly FlagProviderCollection _flagProviderCollection;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="PublishableContentPresentationFactoryBase{TEntity, TVariantItemResponseModel}"/> class.
+    /// </summary>
+    /// <param name="umbracoMapper">The <see cref="IUmbracoMapper"/> instance used for mapping between models.</param>
+    /// <param name="flagProviderCollection">The <see cref="FlagProviderCollection"/> instance used for determining flags to populate on response models.</param>
+    protected PublishableContentPresentationFactoryBase(
+        IUmbracoMapper umbracoMapper,
+        FlagProviderCollection flagProviderCollection)
+    {
+        UmbracoMapper = umbracoMapper;
+        _flagProviderCollection = flagProviderCollection;
+    }
+
+    /// <summary>
+    /// Gets the <see cref="IUmbracoMapper"/> instance.
+    /// </summary>
+    protected IUmbracoMapper UmbracoMapper { get; }
+
+    /// <summary>
+    /// Creates variant item response models for an entity, including one per culture for culture-varying content.
+    /// </summary>
+    /// <param name="entity">The entity to create variant models for.</param>
+    /// <returns>The variant item response models.</returns>
+    [Obsolete("Use CreateVariantsItemResponseModelsAsync instead. Scheduled for removal in Umbraco 19.")]
+    public IEnumerable<TVariantItemResponseModel> CreateVariantsItemResponseModels(TEntity entity)
+        => CreateVariantsItemResponseModelsAsync(entity).GetAwaiter().GetResult();
+
+    /// <summary>
+    /// Asynchronously creates variant item response models for an entity, including one per culture for culture-varying content.
+    /// </summary>
+    /// <param name="entity">The entity to create variant models for.</param>
+    /// <returns>The variant item response models.</returns>
+    public async Task<IEnumerable<TVariantItemResponseModel>> CreateVariantsItemResponseModelsAsync(TEntity entity)
+    {
+        var models = new List<TVariantItemResponseModel>();
+
+        if (entity.Variations.VariesByCulture() is false)
+        {
+            TVariantItemResponseModel model = CreateVariantItemResponseModel(entity.Name ?? string.Empty, DocumentVariantStateHelper.GetState(entity, null), null);
+
+            await PopulateFlagsAsync(model);
+            models.Add(model);
+            return models;
+        }
+
+        foreach (KeyValuePair<string, string> cultureNamePair in entity.CultureNames)
+        {
+            TVariantItemResponseModel model = CreateVariantItemResponseModel(cultureNamePair.Value, DocumentVariantStateHelper.GetState(entity, cultureNamePair.Key), cultureNamePair.Key);
+
+            await PopulateFlagsAsync(model);
+            models.Add(model);
+        }
+
+        return models;
+    }
+
+    /// <summary>
+    /// Creates a <see cref="DocumentTypeReferenceResponseModel"/> for the given entity.
+    /// </summary>
+    /// <param name="entity">The entity to create the document type reference for.</param>
+    /// <returns>The document type reference response model.</returns>
+    public DocumentTypeReferenceResponseModel CreateDocumentTypeReferenceResponseModel(TEntity entity)
+        => UmbracoMapper.Map<DocumentTypeReferenceResponseModel>(entity)!;
+
+    /// <summary>
+    /// Creates a new variant item response model instance with the specified values.
+    /// </summary>
+    /// <param name="name">The variant name.</param>
+    /// <param name="state">The variant state.</param>
+    /// <param name="culture">The culture, or <c>null</c> for invariant content.</param>
+    /// <returns>A new variant item response model.</returns>
+    protected abstract TVariantItemResponseModel CreateVariantItemResponseModel(
+        string name,
+        DocumentVariantState state,
+        string? culture);
+
+    /// <summary>
+    /// Populates flags on a model using all applicable flag providers.
+    /// </summary>
+    /// <typeparam name="TItem">The type of the model supporting flags.</typeparam>
+    /// <param name="model">The model to populate flags on.</param>
+    [Obsolete("Use PopulateFlagsAsync instead. Scheduled for removal in Umbraco 19.")]
+    protected void PopulateFlags<TItem>(TItem model)
+        where TItem : IHasFlags
+        => PopulateFlagsAsync(model).GetAwaiter().GetResult();
+
+    /// <summary>
+    /// Asynchronously populates flags on a model using all applicable flag providers.
+    /// </summary>
+    /// <typeparam name="TItem">The type of the model supporting flags.</typeparam>
+    /// <param name="model">The model to populate flags on.</param>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    protected async Task PopulateFlagsAsync<TItem>(TItem model)
+        where TItem : IHasFlags
+    {
+        foreach (IFlagProvider flagProvider in _flagProviderCollection.Where(x => x.CanProvideFlags<TItem>()))
+        {
+            await flagProvider.PopulateFlagsAsync([model]);
+        }
+    }
+}
diff --git a/src/Umbraco.Cms.Api.Management/Factories/RelationTypePresentationFactory.cs b/src/Umbraco.Cms.Api.Management/Factories/RelationTypePresentationFactory.cs
index 6c7ebb7aa37a..37575cef40a2 100644
--- a/src/Umbraco.Cms.Api.Management/Factories/RelationTypePresentationFactory.cs
+++ b/src/Umbraco.Cms.Api.Management/Factories/RelationTypePresentationFactory.cs
@@ -65,7 +65,7 @@ public RelationTypePresentationFactory(
     }
 
     /// <inheritdoc />
-    public Task<IEnumerable<IReferenceResponseModel>> CreateReferenceResponseModelsAsync(
+    public async Task<IEnumerable<IReferenceResponseModel>> CreateReferenceResponseModelsAsync(
         IEnumerable<RelationItemModel> relationItemModels)
     {
         IReadOnlyCollection<RelationItemModel> relationItemModelsCollection = relationItemModels.ToArray();
@@ -81,17 +81,19 @@ public Task<IEnumerable<IReferenceResponseModel>> CreateReferenceResponseModelsA
             Constants.UdiEntityType.Element,
             Constants.ObjectTypes.Element);
 
-        IReferenceResponseModel[] result = relationItemModelsCollection.Select<RelationItemModel, IReferenceResponseModel?>(relationItemModel =>
+        IEnumerable<Task<IReferenceResponseModel?>> tasks = relationItemModelsCollection.Select<RelationItemModel, Task<IReferenceResponseModel?>>(async relationItemModel =>
             relationItemModel.NodeType switch
             {
-                Constants.ReferenceType.Document => MapReference<DocumentReferenceResponseModel, DocumentEntitySlim>(
+                Constants.ReferenceType.Document => await MapReference<DocumentReferenceResponseModel, DocumentEntitySlim>(
                     relationItemModel,
                     documentSlimEntities,
-                    (r, e) => r.Variants = _documentPresentationFactory.CreateVariantsItemResponseModels(e)),
-                Constants.ReferenceType.Element => MapReference<ElementReferenceResponseModel, IElementEntitySlim>(
+                    async (r, e) => r.Variants
+                        = await _documentPresentationFactory.CreateVariantsItemResponseModelsAsync(e)),
+                Constants.ReferenceType.Element => await MapReference<ElementReferenceResponseModel, IElementEntitySlim>(
                     relationItemModel,
                     elementSlimEntities,
-                    (r, e) => r.Variants = _elementPresentationFactory.CreateVariantsItemResponseModels(e)),
+                    async (r, e) => r.Variants
+                        = await _elementPresentationFactory.CreateVariantsItemResponseModelsAsync(e)),
                 Constants.ReferenceType.ElementContainer => _umbracoMapper.Map<ElementContainerReferenceResponseModel>(relationItemModel),
                 Constants.ReferenceType.Media => _umbracoMapper.Map<MediaReferenceResponseModel>(relationItemModel),
                 Constants.ReferenceType.Member => _umbracoMapper.Map<MemberReferenceResponseModel>(relationItemModel),
@@ -99,15 +101,16 @@ public Task<IEnumerable<IReferenceResponseModel>> CreateReferenceResponseModelsA
                 Constants.ReferenceType.MediaTypePropertyType => _umbracoMapper.Map<MediaTypePropertyTypeReferenceResponseModel>(relationItemModel),
                 Constants.ReferenceType.MemberTypePropertyType => _umbracoMapper.Map<MemberTypePropertyTypeReferenceResponseModel>(relationItemModel),
                 _ => _umbracoMapper.Map<DefaultReferenceResponseModel>(relationItemModel),
-            }).WhereNotNull().ToArray();
+            });
+        IReferenceResponseModel?[] results = await Task.WhenAll(tasks);
 
-        return Task.FromResult<IEnumerable<IReferenceResponseModel>>(result);
+        return results.WhereNotNull().ToArray();
     }
 
-    private TResponse? MapReference<TResponse, TEntity>(
+    private async Task<TResponse?> MapReference<TResponse, TEntity>(
         RelationItemModel relationItemModel,
         List<IEntitySlim> slimEntities,
-        Action<TResponse, TEntity> enrichResponse)
+        Func<TResponse, TEntity, Task> enrichResponse)
         where TResponse : class
         where TEntity : class, IEntitySlim
     {
@@ -118,7 +121,7 @@ public Task<IEnumerable<IReferenceResponseModel>> CreateReferenceResponseModelsA
             return responseModel;
         }
 
-        enrichResponse(responseModel, matchingEntity);
+        await enrichResponse(responseModel, matchingEntity);
         return responseModel;
     }
 
diff --git a/src/Umbraco.Cms.Api.Management/Filters/UserPasswordEnsureMinimumResponseTimeAttribute.cs b/src/Umbraco.Cms.Api.Management/Filters/UserPasswordEnsureMinimumResponseTimeAttribute.cs
index 34440fc0fdb9..ba557acda9fa 100644
--- a/src/Umbraco.Cms.Api.Management/Filters/UserPasswordEnsureMinimumResponseTimeAttribute.cs
+++ b/src/Umbraco.Cms.Api.Management/Filters/UserPasswordEnsureMinimumResponseTimeAttribute.cs
@@ -20,8 +20,8 @@ private sealed class UserPasswordEnsureMinimumResponseTimeFilter : EnsureMinimum
         /// Initializes a new instance of the <see cref="UserPasswordEnsureMinimumResponseTimeFilter"/> class with the specified user password configuration settings.
         /// </summary>
         /// <param name="options">The options containing user password configuration settings.</param>
-        public UserPasswordEnsureMinimumResponseTimeFilter(IOptions<UserPasswordConfigurationSettings> options)
-            : base(options.Value.MinimumResponseTime)
+        public UserPasswordEnsureMinimumResponseTimeFilter(IOptions<SecuritySettings> options)
+            : base(options.Value.UserPassword.MinimumResponseTime)
         {
         }
     }
diff --git a/src/Umbraco.Cms.Api.Management/Mapping/Content/DocumentVariantStateHelper.cs b/src/Umbraco.Cms.Api.Management/Mapping/Content/DocumentVariantStateHelper.cs
index bf9474ce20f9..6eb353aab9a5 100644
--- a/src/Umbraco.Cms.Api.Management/Mapping/Content/DocumentVariantStateHelper.cs
+++ b/src/Umbraco.Cms.Api.Management/Mapping/Content/DocumentVariantStateHelper.cs
@@ -18,27 +18,22 @@ internal static DocumentVariantState GetState(IPublishableContentBase content, s
             content.EditedCultures ?? Enumerable.Empty<string>(),
             content.PublishedCultures);
 
-    internal static DocumentVariantState GetState(IDocumentEntitySlim content, string? culture)
+    internal static DocumentVariantState GetState(IPublishableContentEntitySlim entity, string? culture)
         => GetState(
-            content,
+            entity,
             culture,
-            content.Edited,
-            content.Published,
-            content.Trashed,
-            content.CultureNames.Keys,
-            content.EditedCultures,
-            content.PublishedCultures);
+            entity.Edited,
+            entity.Published,
+            entity.Trashed,
+            entity.CultureNames.Keys,
+            entity.EditedCultures,
+            entity.PublishedCultures);
+
+    internal static DocumentVariantState GetState(IDocumentEntitySlim content, string? culture)
+        => GetState((IPublishableContentEntitySlim)content, culture);
 
     internal static DocumentVariantState GetState(IElementEntitySlim element, string? culture)
-        => GetState(
-            element,
-            culture,
-            element.Edited,
-            element.Published,
-            element.Trashed,
-            element.CultureNames.Keys,
-            element.EditedCultures,
-            element.PublishedCultures);
+        => GetState((IPublishableContentEntitySlim)element, culture);
 
     private static DocumentVariantState GetState(IEntity entity, string? culture, bool edited, bool published, bool trashed, IEnumerable<string> availableCultures, IEnumerable<string> editedCultures, IEnumerable<string> publishedCultures)
     {
diff --git a/src/Umbraco.Cms.Api.Management/OpenApi.json b/src/Umbraco.Cms.Api.Management/OpenApi.json
index 17bec416c5e9..e73d5aeb598b 100644
--- a/src/Umbraco.Cms.Api.Management/OpenApi.json
+++ b/src/Umbraco.Cms.Api.Management/OpenApi.json
@@ -55,7 +55,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -203,7 +203,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -265,7 +265,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -376,7 +376,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -518,7 +518,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -651,7 +651,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -709,7 +709,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -827,7 +827,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -893,7 +893,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -953,7 +953,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1004,7 +1004,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1041,7 +1041,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1189,7 +1189,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1251,7 +1251,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -1362,7 +1362,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -1504,7 +1504,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1552,7 +1552,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1631,7 +1631,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1682,7 +1682,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1733,7 +1733,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1794,7 +1794,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1844,7 +1844,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1917,7 +1917,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -1982,7 +1982,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -2051,7 +2051,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -2122,7 +2122,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -2186,7 +2186,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -2358,7 +2358,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -2420,7 +2420,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -2531,7 +2531,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -2673,7 +2673,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -2744,7 +2744,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -2888,7 +2888,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -3036,7 +3036,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -3087,7 +3087,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -3137,7 +3137,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -3202,7 +3202,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -3259,7 +3259,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -3407,7 +3407,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -3469,7 +3469,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -3580,7 +3580,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -3722,7 +3722,88 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
+          }
+        ]
+      }
+    },
+    "/umbraco/management/api/v1/document-blueprint/{id}/audit-log": {
+      "get": {
+        "tags": [
+          "Document Blueprint"
+        ],
+        "summary": "Gets the audit log for a document blueprint.",
+        "description": "Gets a paginated collection of audit log entries for the document blueprint identified by the provided Id.",
+        "operationId": "GetDocumentBlueprintByIdAuditLog",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "uuid"
+            }
+          },
+          {
+            "name": "orderDirection",
+            "in": "query",
+            "schema": {
+              "$ref": "#/components/schemas/DirectionModel"
+            }
+          },
+          {
+            "name": "sinceDate",
+            "in": "query",
+            "schema": {
+              "type": "string",
+              "format": "date-time"
+            }
+          },
+          {
+            "name": "skip",
+            "in": "query",
+            "schema": {
+              "type": "integer",
+              "format": "int32",
+              "default": 0
+            }
+          },
+          {
+            "name": "take",
+            "in": "query",
+            "schema": {
+              "type": "integer",
+              "format": "int32",
+              "default": 100
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "oneOf": [
+                    {
+                      "$ref": "#/components/schemas/PagedAuditLogResponseModel"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          "401": {
+            "description": "The resource is protected and requires an authentication token"
+          },
+          "403": {
+            "description": "The authenticated user does not have access to this resource"
+          }
+        },
+        "security": [
+          {
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -3840,7 +3921,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -3902,7 +3983,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -4050,7 +4131,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -4112,7 +4193,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -4223,7 +4304,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -4365,7 +4446,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -4487,7 +4568,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -4538,7 +4619,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -4588,7 +4669,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -4661,7 +4742,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -4726,7 +4807,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -4797,7 +4878,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -4945,7 +5026,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -5007,7 +5088,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -5092,7 +5173,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -5234,7 +5315,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -5322,7 +5403,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -5384,7 +5465,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -5464,7 +5545,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -5543,7 +5624,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -5702,7 +5783,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -5765,7 +5846,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -5909,7 +5990,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -6053,7 +6134,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -6116,7 +6197,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -6249,7 +6330,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -6306,7 +6387,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -6363,7 +6444,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -6458,7 +6539,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -6509,7 +6590,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -6546,7 +6627,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -6694,7 +6775,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -6756,7 +6837,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -6867,7 +6948,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -7009,7 +7090,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7157,7 +7238,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7208,7 +7289,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7259,7 +7340,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7327,7 +7408,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7377,7 +7458,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7450,7 +7531,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7515,7 +7596,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7584,7 +7665,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7655,7 +7736,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7756,7 +7837,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7832,7 +7913,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -7952,7 +8033,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -8072,7 +8153,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -8203,7 +8284,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -8351,7 +8432,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -8413,7 +8494,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -8524,7 +8605,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -8666,7 +8747,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -8747,7 +8828,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -8828,7 +8909,7 @@
         "deprecated": true,
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -8961,7 +9042,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -9023,7 +9104,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -9191,7 +9272,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -9309,7 +9390,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -9422,7 +9503,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -9487,7 +9568,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -9603,7 +9684,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -9700,7 +9781,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -9833,7 +9914,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -9918,7 +9999,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -9986,7 +10067,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -10102,7 +10183,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -10246,7 +10327,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -10401,7 +10482,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -10486,7 +10567,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -10548,7 +10629,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -10628,7 +10709,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -10708,7 +10789,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -10852,7 +10933,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -10996,7 +11077,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11065,7 +11146,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11102,7 +11183,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11235,7 +11316,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11289,7 +11370,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11422,7 +11503,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11473,7 +11554,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11524,7 +11605,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11626,7 +11707,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11702,7 +11783,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11815,7 +11896,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -11891,7 +11972,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12035,7 +12116,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12100,7 +12181,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12157,7 +12238,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12214,7 +12295,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12285,7 +12366,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12335,7 +12416,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12408,7 +12489,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12473,7 +12554,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12544,7 +12625,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12636,7 +12717,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12672,7 +12753,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12773,7 +12854,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12849,7 +12930,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -12969,7 +13050,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -13089,7 +13170,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -13237,7 +13318,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -13299,7 +13380,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -13410,7 +13491,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -13552,7 +13633,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -13633,7 +13714,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -13766,7 +13847,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -13884,7 +13965,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -13997,7 +14078,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -14141,7 +14222,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -14221,7 +14302,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -14365,7 +14446,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -14509,7 +14590,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -14578,7 +14659,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -14615,7 +14696,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -14763,7 +14844,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -14825,7 +14906,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -14936,7 +15017,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -15078,7 +15159,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -15222,7 +15303,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -15335,7 +15416,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -15415,7 +15496,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -15548,7 +15629,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -15599,7 +15680,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -15650,7 +15731,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -15726,7 +15807,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -15839,7 +15920,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -15915,7 +15996,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16059,7 +16140,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16124,7 +16205,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16237,7 +16318,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16313,7 +16394,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16457,7 +16538,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16514,7 +16595,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16571,7 +16652,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16642,7 +16723,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16692,7 +16773,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16739,6 +16820,14 @@
               "type": "boolean",
               "default": false
             }
+          },
+          {
+            "name": "dataTypeId",
+            "in": "query",
+            "schema": {
+              "type": "string",
+              "format": "uuid"
+            }
           }
         ],
         "responses": {
@@ -16765,7 +16854,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16804,6 +16893,14 @@
               "type": "boolean",
               "default": false
             }
+          },
+          {
+            "name": "dataTypeId",
+            "in": "query",
+            "schema": {
+              "type": "string",
+              "format": "uuid"
+            }
           }
         ],
         "responses": {
@@ -16830,7 +16927,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16875,6 +16972,14 @@
               "type": "boolean",
               "default": false
             }
+          },
+          {
+            "name": "dataTypeId",
+            "in": "query",
+            "schema": {
+              "type": "string",
+              "format": "uuid"
+            }
           }
         ],
         "responses": {
@@ -16901,7 +17006,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -16958,7 +17063,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -17019,7 +17124,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -17116,7 +17221,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -17234,7 +17339,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -17325,7 +17430,7 @@
         "deprecated": true,
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -17411,7 +17516,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -17483,7 +17588,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -17537,7 +17642,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -17595,7 +17700,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -17718,7 +17823,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -17976,7 +18081,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -18010,7 +18115,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -18064,7 +18169,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -18210,7 +18315,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -18268,7 +18373,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -18378,7 +18483,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -18519,7 +18624,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -18576,7 +18681,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -18645,7 +18750,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -18742,7 +18847,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -18829,7 +18934,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -18886,7 +18991,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -19006,7 +19111,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19067,7 +19172,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -19151,7 +19256,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19209,7 +19314,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19249,7 +19354,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19289,7 +19394,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19369,7 +19474,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19430,7 +19535,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19481,7 +19586,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19535,7 +19640,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19596,7 +19701,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19744,7 +19849,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -19806,7 +19911,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -19891,7 +19996,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -20033,7 +20138,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -20121,7 +20226,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -20183,7 +20288,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -20262,7 +20367,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -20421,7 +20526,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -20484,7 +20589,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -20628,7 +20733,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -20772,7 +20877,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -20835,7 +20940,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -20892,7 +20997,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -20987,7 +21092,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -21038,7 +21143,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -21075,7 +21180,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -21223,7 +21328,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -21285,7 +21390,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -21396,7 +21501,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -21538,7 +21643,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -21686,7 +21791,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -21736,7 +21841,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -21809,7 +21914,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -21874,7 +21979,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -21945,7 +22050,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -22068,7 +22173,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -22119,7 +22224,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -22170,7 +22275,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -22272,7 +22377,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -22420,7 +22525,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -22482,7 +22587,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -22593,7 +22698,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -22735,7 +22840,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -22816,7 +22921,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -22934,7 +23039,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23047,7 +23152,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23127,7 +23232,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23207,7 +23312,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23351,7 +23456,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23420,7 +23525,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23457,7 +23562,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23590,7 +23695,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23644,7 +23749,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23777,7 +23882,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23853,7 +23958,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -23966,7 +24071,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24042,7 +24147,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24186,7 +24291,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24251,7 +24356,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24308,7 +24413,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24365,7 +24470,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24436,7 +24541,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24486,7 +24591,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24559,7 +24664,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24624,7 +24729,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24695,7 +24800,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24746,7 +24851,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24803,7 +24908,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -24923,7 +25028,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -24974,7 +25079,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -25085,7 +25190,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -25227,7 +25332,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -25284,7 +25389,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -25335,7 +25440,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -25386,7 +25491,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -25447,7 +25552,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -25595,7 +25700,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -25657,7 +25762,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -25742,7 +25847,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -25884,7 +25989,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -25963,7 +26068,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26122,7 +26227,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26185,7 +26290,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26329,7 +26434,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26473,7 +26578,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26536,7 +26641,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26593,7 +26698,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26688,7 +26793,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26739,7 +26844,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26776,7 +26881,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26924,7 +27029,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -26986,7 +27091,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -27097,7 +27202,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -27239,7 +27344,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -27387,7 +27492,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -27437,7 +27542,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -27510,7 +27615,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -27575,7 +27680,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -27646,7 +27751,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -27768,7 +27873,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -27819,7 +27924,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -27870,7 +27975,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -27942,7 +28047,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -28090,7 +28195,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -28152,7 +28257,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -28263,7 +28368,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -28405,7 +28510,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -28485,7 +28590,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -28565,7 +28670,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -28709,7 +28814,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -28778,7 +28883,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -28815,7 +28920,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -28948,7 +29053,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29024,7 +29129,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29061,7 +29166,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29098,7 +29203,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29132,7 +29237,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29186,7 +29291,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29249,7 +29354,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29361,7 +29466,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29398,7 +29503,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29455,7 +29560,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -29601,7 +29706,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29663,7 +29768,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -29748,7 +29853,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -29864,7 +29969,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29927,7 +30032,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -29984,7 +30089,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -30034,7 +30139,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -30182,7 +30287,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -30243,7 +30348,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -30353,7 +30458,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -30494,7 +30599,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -30652,7 +30757,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -30800,7 +30905,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -30861,7 +30966,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -30971,7 +31076,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31028,7 +31133,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31089,7 +31194,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31138,7 +31243,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31202,7 +31307,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31259,7 +31364,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31321,7 +31426,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31385,7 +31490,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -31464,7 +31569,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31528,7 +31633,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31563,7 +31668,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31597,7 +31702,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31632,7 +31737,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31710,7 +31815,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31776,7 +31881,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -31835,7 +31940,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31872,7 +31977,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -31929,7 +32034,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -31980,7 +32085,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -32037,7 +32142,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -32099,7 +32204,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -32179,7 +32284,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -32229,7 +32334,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -32377,7 +32482,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -32438,7 +32543,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -32548,7 +32653,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -32689,7 +32794,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -32847,7 +32952,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -32995,7 +33100,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -33056,7 +33161,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -33166,7 +33271,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -33215,7 +33320,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -33279,7 +33384,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -33336,7 +33441,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -33398,7 +33503,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -33452,7 +33557,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -33535,7 +33640,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -33572,7 +33677,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -33679,7 +33784,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -33812,7 +33917,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34001,7 +34106,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34061,7 +34166,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34135,7 +34240,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34173,7 +34278,7 @@
         "deprecated": true,
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34223,7 +34328,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34269,7 +34374,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34330,7 +34435,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34384,7 +34489,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34434,7 +34539,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34582,7 +34687,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -34643,7 +34748,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -34753,7 +34858,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -34894,7 +34999,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35052,7 +35157,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35200,7 +35305,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35261,7 +35366,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -35371,7 +35476,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35420,7 +35525,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35484,7 +35589,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35541,7 +35646,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35603,7 +35708,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35678,7 +35783,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35735,7 +35840,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35772,7 +35877,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -35877,7 +35982,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35928,7 +36033,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -35979,7 +36084,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -36040,7 +36145,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -36188,7 +36293,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -36250,7 +36355,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -36361,7 +36466,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -36503,7 +36608,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -36540,7 +36645,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -36632,7 +36737,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -36669,7 +36774,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -36719,7 +36824,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -36784,7 +36889,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -36841,7 +36946,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -36904,7 +37009,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -37011,7 +37116,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -37084,7 +37189,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -37180,7 +37285,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -37214,7 +37319,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -37316,7 +37421,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -37367,7 +37472,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -37492,7 +37597,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -37564,7 +37669,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -37672,7 +37777,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -37720,7 +37825,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -37808,7 +37913,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -37901,7 +38006,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -37952,7 +38057,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -38059,7 +38164,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -38179,7 +38284,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -38234,7 +38339,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -38296,7 +38401,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -38381,7 +38486,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -38497,7 +38602,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -38624,7 +38729,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -38749,7 +38854,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -38879,7 +38984,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -38930,7 +39035,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -39078,7 +39183,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -39183,7 +39288,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -39252,7 +39357,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -39314,7 +39419,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -39425,7 +39530,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -39567,7 +39672,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -39632,7 +39737,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -39753,7 +39858,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -39815,7 +39920,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -39959,7 +40064,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -40077,7 +40182,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -40122,7 +40227,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -40217,7 +40322,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -40341,7 +40446,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -40454,7 +40559,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -40596,7 +40701,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -40633,7 +40738,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -40667,7 +40772,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -40704,7 +40809,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -40808,7 +40913,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -40945,7 +41050,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -41015,7 +41120,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41107,7 +41212,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41199,7 +41304,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41236,7 +41341,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41273,7 +41378,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41335,7 +41440,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41400,7 +41505,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41463,7 +41568,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41525,7 +41630,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41658,7 +41763,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41791,7 +41896,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -41939,7 +42044,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -42197,7 +42302,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -42414,7 +42519,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -42521,7 +42626,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -42572,7 +42677,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -42629,7 +42734,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -42775,7 +42880,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -42837,7 +42942,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -42948,7 +43053,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       },
@@ -43090,7 +43195,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -43156,7 +43261,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -43213,7 +43318,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -43270,7 +43375,7 @@
         },
         "security": [
           {
-            "Backoffice-User": []
+            "Backoffice-User": [ ]
           }
         ]
       }
@@ -47809,6 +47914,21 @@
             "type": "string",
             "format": "date-time"
           },
+          "id": {
+            "type": "string",
+            "format": "uuid",
+            "readOnly": true
+          },
+          "flags": {
+            "type": "array",
+            "items": {
+              "oneOf": [
+                {
+                  "$ref": "#/components/schemas/FlagModel"
+                }
+              ]
+            }
+          },
           "state": {
             "$ref": "#/components/schemas/DocumentVariantStateModel"
           },
@@ -47826,21 +47946,6 @@
             "type": "string",
             "format": "date-time",
             "nullable": true
-          },
-          "id": {
-            "type": "string",
-            "format": "uuid",
-            "readOnly": true
-          },
-          "flags": {
-            "type": "array",
-            "items": {
-              "oneOf": [
-                {
-                  "$ref": "#/components/schemas/FlagModel"
-                }
-              ]
-            }
           }
         },
         "additionalProperties": false
@@ -48576,6 +48681,8 @@
       },
       "ElementVariantItemResponseModel": {
         "required": [
+          "flags",
+          "id",
           "name",
           "state"
         ],
@@ -48588,6 +48695,21 @@
             "type": "string",
             "nullable": true
           },
+          "id": {
+            "type": "string",
+            "format": "uuid",
+            "readOnly": true
+          },
+          "flags": {
+            "type": "array",
+            "items": {
+              "oneOf": [
+                {
+                  "$ref": "#/components/schemas/FlagModel"
+                }
+              ]
+            }
+          },
           "state": {
             "$ref": "#/components/schemas/DocumentVariantStateModel"
           }
@@ -48618,6 +48740,8 @@
       "ElementVariantResponseModel": {
         "required": [
           "createDate",
+          "flags",
+          "id",
           "name",
           "state",
           "updateDate"
@@ -48644,6 +48768,21 @@
             "type": "string",
             "format": "date-time"
           },
+          "id": {
+            "type": "string",
+            "format": "uuid",
+            "readOnly": true
+          },
+          "flags": {
+            "type": "array",
+            "items": {
+              "oneOf": [
+                {
+                  "$ref": "#/components/schemas/FlagModel"
+                }
+              ]
+            }
+          },
           "state": {
             "$ref": "#/components/schemas/DocumentVariantStateModel"
           },
@@ -49040,7 +49179,7 @@
           },
           "actionParameters": {
             "type": "object",
-            "additionalProperties": {},
+            "additionalProperties": { },
             "nullable": true
           }
         },
@@ -49348,6 +49487,10 @@
               "nullable": true
             },
             "nullable": true
+          },
+          "uniqueKeyFieldName": {
+            "type": "string",
+            "nullable": true
           }
         },
         "additionalProperties": false
@@ -49848,7 +49991,7 @@
           },
           "extensions": {
             "type": "array",
-            "items": {}
+            "items": { }
           }
         },
         "additionalProperties": false
@@ -53957,7 +54100,7 @@
             "nullable": true
           }
         },
-        "additionalProperties": {}
+        "additionalProperties": { }
       },
       "ProblemDetailsBuilderModel": {
         "type": "object",
@@ -58488,7 +58631,7 @@
           "authorizationCode": {
             "authorizationUrl": "/umbraco/management/api/v1/security/back-office/authorize",
             "tokenUrl": "/umbraco/management/api/v1/security/back-office/token",
-            "scopes": {}
+            "scopes": { }
           }
         }
       }
diff --git a/src/Umbraco.Cms.Api.Management/Security/ConfigureBackOfficeIdentityOptions.cs b/src/Umbraco.Cms.Api.Management/Security/ConfigureBackOfficeIdentityOptions.cs
index 467e2ceb08cb..bc159cdd087c 100644
--- a/src/Umbraco.Cms.Api.Management/Security/ConfigureBackOfficeIdentityOptions.cs
+++ b/src/Umbraco.Cms.Api.Management/Security/ConfigureBackOfficeIdentityOptions.cs
@@ -12,20 +12,29 @@ namespace Umbraco.Cms.Api.Management.Security;
 /// </summary>
 public sealed class ConfigureBackOfficeIdentityOptions : IConfigureOptions<BackOfficeIdentityOptions>
 {
-    private readonly UserPasswordConfigurationSettings _userPasswordConfiguration;
     private readonly SecuritySettings _securitySettings;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConfigureBackOfficeIdentityOptions"/> class with the specified user password configuration and security settings.
+    /// </summary>
+    /// <param name="securitySettings">The options containing security settings.</param>
+    public ConfigureBackOfficeIdentityOptions(
+        IOptions<SecuritySettings> securitySettings)
+    {
+        _securitySettings = securitySettings.Value;
+    }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="ConfigureBackOfficeIdentityOptions"/> class with the specified user password configuration and security settings.
     /// </summary>
     /// <param name="userPasswordConfiguration">The options containing user password configuration settings.</param>
     /// <param name="securitySettings">The options containing security settings.</param>
+    [Obsolete("Use the constructor that only takes IOptions<SecuritySettings> instead. Scheduled for removal in Umbraco 19.")]
     public ConfigureBackOfficeIdentityOptions(
         IOptions<UserPasswordConfigurationSettings> userPasswordConfiguration,
         IOptions<SecuritySettings> securitySettings)
+        : this(securitySettings)
     {
-        _userPasswordConfiguration = userPasswordConfiguration.Value;
-        _securitySettings = securitySettings.Value;
     }
 
     /// <summary>
@@ -50,8 +59,8 @@ public void Configure(BackOfficeIdentityOptions options)
         options.Lockout.AllowedForNewUsers = true;
         options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(_securitySettings.UserDefaultLockoutTimeInMinutes);
 
-        options.Password.ConfigurePasswordOptions(_userPasswordConfiguration);
+        options.Password.ConfigurePasswordOptions(_securitySettings.UserPassword);
 
-        options.Lockout.MaxFailedAccessAttempts = _userPasswordConfiguration.MaxFailedAccessAttemptsBeforeLockout;
+        options.Lockout.MaxFailedAccessAttempts = _securitySettings.UserPassword.MaxFailedAccessAttemptsBeforeLockout;
     }
 }
diff --git a/src/Umbraco.Cms.Api.Management/Security/ForgotPasswordUriProvider.cs b/src/Umbraco.Cms.Api.Management/Security/ForgotPasswordUriProvider.cs
index e0f88a6caf81..7d71500a2ce6 100644
--- a/src/Umbraco.Cms.Api.Management/Security/ForgotPasswordUriProvider.cs
+++ b/src/Umbraco.Cms.Api.Management/Security/ForgotPasswordUriProvider.cs
@@ -1,8 +1,5 @@
 using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Routing;
-using Microsoft.Extensions.Options;
 using Umbraco.Cms.Core;
-using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Hosting;
 using Umbraco.Cms.Core.Models.Membership;
 using Umbraco.Cms.Core.Security;
@@ -16,7 +13,6 @@ namespace Umbraco.Cms.Api.Management.Security;
 /// </summary>
 public class ForgotPasswordUriProvider : IForgotPasswordUriProvider
 {
-
     private readonly ICoreBackOfficeUserManager _userManager;
     private readonly IHostingEnvironment _hostingEnvironment;
     private readonly IHttpContextAccessor _httpContextAccessor;
@@ -37,29 +33,37 @@ public ForgotPasswordUriProvider(
         _httpContextAccessor = httpContextAccessor;
     }
 
+    /// <inheritdoc/>
     public async Task<Attempt<Uri, UserOperationStatus>> CreateForgotPasswordUriAsync(IUser user)
     {
-        Attempt<string, UserOperationStatus> tokenAttempt = await _userManager.GeneratePasswordResetTokenAsync(user);
+        if (_httpContextAccessor.HttpContext is null)
+        {
+            throw new NotSupportedException("Needs a HttpContext");
+        }
 
-        if (tokenAttempt.Success is false)
+        Uri? appUrl = _hostingEnvironment.ApplicationMainUrl;
+        if (appUrl is null)
         {
-            return Attempt.FailWithStatus(tokenAttempt.Status, new Uri(string.Empty));
+            return Attempt.FailWithStatus<Uri, UserOperationStatus>(UserOperationStatus.ApplicationUrlNotConfigured, default!);
         }
 
-        HttpRequest? request = _httpContextAccessor.HttpContext?.Request;
-        if (request is null)
+        Attempt<string, UserOperationStatus> tokenAttempt = await _userManager.GeneratePasswordResetTokenAsync(user);
+
+        if (tokenAttempt.Success is false)
         {
-            throw new NotSupportedException("Needs a HttpContext");
+            return Attempt.FailWithStatus<Uri, UserOperationStatus>(tokenAttempt.Status, default!);
         }
 
-        var uriBuilder = new UriBuilder(_hostingEnvironment.ApplicationMainUrl);
-        uriBuilder.Path = BackOfficeLoginController.LoginPath;
-        uriBuilder.Query = QueryString.Create(new KeyValuePair<string, string?>[]
+        var uriBuilder = new UriBuilder(appUrl)
         {
-            new ("flow", "reset-password"),
-            new ("userId", user.Key.ToString()),
-            new ("resetCode", tokenAttempt.Result.ToUrlBase64()),
-        }).ToUriComponent();
+            Path = BackOfficeLoginController.LoginPath,
+            Query = QueryString.Create(new KeyValuePair<string, string?>[]
+            {
+                new("flow", "reset-password"),
+                new("userId", user.Key.ToString()),
+                new("resetCode", tokenAttempt.Result.ToUrlBase64()),
+            }).ToUriComponent(),
+        };
 
         return Attempt.SucceedWithStatus(UserOperationStatus.Success, uriBuilder.Uri);
     }
diff --git a/src/Umbraco.Cms.Api.Management/Security/InviteUriProvider.cs b/src/Umbraco.Cms.Api.Management/Security/InviteUriProvider.cs
index dc1e9637d9d0..0a890427441a 100644
--- a/src/Umbraco.Cms.Api.Management/Security/InviteUriProvider.cs
+++ b/src/Umbraco.Cms.Api.Management/Security/InviteUriProvider.cs
@@ -28,7 +28,6 @@ public InviteUriProvider(
         IHttpContextAccessor httpContextAccessor,
         IHostingEnvironment hostingEnvironment)
     {
-
         _userManager = userManager;
         _httpContextAccessor = httpContextAccessor;
         _hostingEnvironment = hostingEnvironment;
@@ -43,27 +42,34 @@ public InviteUriProvider(
     /// </returns>
     public async Task<Attempt<Uri, UserOperationStatus>> CreateInviteUriAsync(IUser invitee)
     {
-        Attempt<string, UserOperationStatus> tokenAttempt = await _userManager.GenerateEmailConfirmationTokenAsync(invitee);
+        if (_httpContextAccessor.HttpContext is null)
+        {
+            throw new NotSupportedException("Needs a HttpContext");
+        }
 
-        if (tokenAttempt.Success is false)
+        Uri? appUrl = _hostingEnvironment.ApplicationMainUrl;
+        if (appUrl is null)
         {
-            return Attempt.FailWithStatus(tokenAttempt.Status, new Uri(string.Empty));
+            return Attempt.FailWithStatus<Uri, UserOperationStatus>(UserOperationStatus.ApplicationUrlNotConfigured, default!);
         }
 
-        HttpRequest? request = _httpContextAccessor.HttpContext?.Request;
-        if (request is null)
+        Attempt<string, UserOperationStatus> tokenAttempt = await _userManager.GenerateEmailConfirmationTokenAsync(invitee);
+
+        if (tokenAttempt.Success is false)
         {
-            throw new NotSupportedException("Needs a HttpContext");
+            return Attempt.FailWithStatus<Uri, UserOperationStatus>(tokenAttempt.Status, default!);
         }
 
-        var uriBuilder = new UriBuilder(_hostingEnvironment.ApplicationMainUrl);
-        uriBuilder.Path = BackOfficeLoginController.LoginPath;
-        uriBuilder.Query = QueryString.Create(new KeyValuePair<string, string?>[]
+        var uriBuilder = new UriBuilder(appUrl)
         {
-            new ("flow", "invite-user"),
-            new ("userId", invitee.Key.ToString()),
-            new ("inviteCode", tokenAttempt.Result.ToUrlBase64()),
-        }).ToUriComponent();
+            Path = BackOfficeLoginController.LoginPath,
+            Query = QueryString.Create(new KeyValuePair<string, string?>[]
+            {
+                new ("flow", "invite-user"),
+                new ("userId", invitee.Key.ToString()),
+                new ("inviteCode", tokenAttempt.Result.ToUrlBase64()),
+            }).ToUriComponent()
+        };
 
         return Attempt.SucceedWithStatus(UserOperationStatus.Success, uriBuilder.Uri);
     }
diff --git a/src/Umbraco.Cms.Api.Management/Services/Flags/HasDocumentScheduleFlagProvider.cs b/src/Umbraco.Cms.Api.Management/Services/Flags/HasDocumentScheduleFlagProvider.cs
new file mode 100644
index 000000000000..9a31ae05168e
--- /dev/null
+++ b/src/Umbraco.Cms.Api.Management/Services/Flags/HasDocumentScheduleFlagProvider.cs
@@ -0,0 +1,49 @@
+using Umbraco.Cms.Api.Management.ViewModels;
+using Umbraco.Cms.Api.Management.ViewModels.Document.Collection;
+using Umbraco.Cms.Api.Management.ViewModels.Document.Item;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Services.Flags;
+
+/// <summary>
+/// Provides flags for documents that are scheduled for publication.
+/// </summary>
+internal class HasDocumentScheduleFlagProvider : HasScheduleFlagProviderBase
+{
+    private readonly IContentService _contentService;
+
+    public HasDocumentScheduleFlagProvider(IContentService contentService, TimeProvider timeProvider)
+        : base(timeProvider)
+    {
+        _contentService = contentService;
+    }
+
+    /// <inheritdoc/>
+    public override bool CanProvideFlags<TItem>() =>
+        typeof(TItem) == typeof(DocumentTreeItemResponseModel) ||
+        typeof(TItem) == typeof(DocumentCollectionResponseModel) ||
+        typeof(TItem) == typeof(DocumentItemResponseModel);
+
+    /// <inheritdoc/>
+    protected override IDictionary<Guid, IEnumerable<ContentSchedule>> GetSchedulesByKeys(Guid[] keys)
+        => _contentService.GetContentSchedulesByKeys(keys);
+
+    /// <inheritdoc/>
+    protected override void PopulateItemFlags<TItem>(TItem item, ContentSchedule[] releaseSchedules)
+    {
+        switch (item)
+        {
+            case DocumentTreeItemResponseModel m:
+                m.Variants = PopulateVariants(m.Variants, releaseSchedules, v => v.Culture);
+                break;
+            case DocumentCollectionResponseModel m:
+                m.Variants = PopulateVariants(m.Variants, releaseSchedules, v => v.Culture);
+                break;
+            case DocumentItemResponseModel m:
+                m.Variants = PopulateVariants(m.Variants, releaseSchedules, v => v.Culture);
+                break;
+        }
+    }
+}
diff --git a/src/Umbraco.Cms.Api.Management/Services/Flags/HasElementScheduleFlagProvider.cs b/src/Umbraco.Cms.Api.Management/Services/Flags/HasElementScheduleFlagProvider.cs
new file mode 100644
index 000000000000..b557e09b48f7
--- /dev/null
+++ b/src/Umbraco.Cms.Api.Management/Services/Flags/HasElementScheduleFlagProvider.cs
@@ -0,0 +1,44 @@
+using Umbraco.Cms.Api.Management.ViewModels;
+using Umbraco.Cms.Api.Management.ViewModels.Element.Item;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Services.Flags;
+
+/// <summary>
+/// Provides flags for elements that are scheduled for publication.
+/// </summary>
+internal class HasElementScheduleFlagProvider : HasScheduleFlagProviderBase
+{
+    private readonly IElementService _elementService;
+
+    public HasElementScheduleFlagProvider(IElementService elementService, TimeProvider timeProvider)
+        : base(timeProvider)
+    {
+        _elementService = elementService;
+    }
+
+    /// <inheritdoc/>
+    public override bool CanProvideFlags<TItem>() =>
+        typeof(TItem) == typeof(ElementTreeItemResponseModel) ||
+        typeof(TItem) == typeof(ElementItemResponseModel);
+
+    /// <inheritdoc/>
+    protected override IDictionary<Guid, IEnumerable<ContentSchedule>> GetSchedulesByKeys(Guid[] keys)
+        => _elementService.GetContentSchedulesByKeys(keys);
+
+    /// <inheritdoc/>
+    protected override void PopulateItemFlags<TItem>(TItem item, ContentSchedule[] releaseSchedules)
+    {
+        switch (item)
+        {
+            case ElementTreeItemResponseModel m:
+                m.Variants = PopulateVariants(m.Variants, releaseSchedules, v => v.Culture);
+                break;
+            case ElementItemResponseModel m:
+                m.Variants = PopulateVariants(m.Variants, releaseSchedules, v => v.Culture);
+                break;
+        }
+    }
+}
diff --git a/src/Umbraco.Cms.Api.Management/Services/Flags/HasPendingChangesFlagProvider.cs b/src/Umbraco.Cms.Api.Management/Services/Flags/HasPendingChangesFlagProvider.cs
index 0a8be1d75c57..e67c2dd90996 100644
--- a/src/Umbraco.Cms.Api.Management/Services/Flags/HasPendingChangesFlagProvider.cs
+++ b/src/Umbraco.Cms.Api.Management/Services/Flags/HasPendingChangesFlagProvider.cs
@@ -1,11 +1,12 @@
-using Umbraco.Cms.Api.Management.ViewModels;
+using Umbraco.Cms.Api.Management.ViewModels;
 using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Api.Management.ViewModels.Element;
 using Umbraco.Cms.Core;
 
 namespace Umbraco.Cms.Api.Management.Services.Flags;
 
 /// <summary>
-/// Implements a <see cref="IFlagProvider"/> that provides flags for documents that have pending changes.
+/// Implements a <see cref="IFlagProvider"/> that provides flags for documents and elements that have pending changes.
 /// </summary>
 public class HasPendingChangesFlagProvider : IFlagProvider
 {
@@ -15,8 +16,9 @@ public class HasPendingChangesFlagProvider : IFlagProvider
     public bool CanProvideFlags<TItem>()
         where TItem : IHasFlags =>
         typeof(TItem) == typeof(DocumentVariantItemResponseModel) ||
-        typeof(TItem) == typeof(DocumentVariantResponseModel);
-
+        typeof(TItem) == typeof(DocumentVariantResponseModel) ||
+        typeof(TItem) == typeof(ElementVariantItemResponseModel) ||
+        typeof(TItem) == typeof(ElementVariantResponseModel);
 
     /// <inheritdoc/>
     public Task PopulateFlagsAsync<TItem>(IEnumerable<TItem> items)
@@ -24,7 +26,16 @@ public Task PopulateFlagsAsync<TItem>(IEnumerable<TItem> items)
     {
         foreach (TItem item in items)
         {
-            if (HasPendingChanges(item))
+            DocumentVariantState? state = item switch
+            {
+                DocumentVariantItemResponseModel variant => variant.State,
+                DocumentVariantResponseModel variant => variant.State,
+                ElementVariantItemResponseModel variant => variant.State,
+                ElementVariantResponseModel variant => variant.State,
+                _ => null,
+            };
+
+            if (state == DocumentVariantState.PublishedPendingChanges)
             {
                 item.AddFlag(Alias);
             }
@@ -32,14 +43,4 @@ public Task PopulateFlagsAsync<TItem>(IEnumerable<TItem> items)
 
         return Task.CompletedTask;
     }
-
-    /// <summary>
-    /// Determines if the given item has any variant that has pending changes.
-    /// </summary>
-    private static bool HasPendingChanges(object item) => item switch
-    {
-        DocumentVariantItemResponseModel variant => variant.State == DocumentVariantState.PublishedPendingChanges,
-        DocumentVariantResponseModel variant => variant.State == DocumentVariantState.PublishedPendingChanges,
-        _ => false,
-    };
 }
diff --git a/src/Umbraco.Cms.Api.Management/Services/Flags/HasScheduleFlagProvider.cs b/src/Umbraco.Cms.Api.Management/Services/Flags/HasScheduleFlagProvider.cs
deleted file mode 100644
index 7d4190d5985f..000000000000
--- a/src/Umbraco.Cms.Api.Management/Services/Flags/HasScheduleFlagProvider.cs
+++ /dev/null
@@ -1,117 +0,0 @@
-using Umbraco.Cms.Api.Management.ViewModels;
-using Umbraco.Cms.Api.Management.ViewModels.Document;
-using Umbraco.Cms.Api.Management.ViewModels.Document.Collection;
-using Umbraco.Cms.Api.Management.ViewModels.Document.Item;
-using Umbraco.Cms.Api.Management.ViewModels.Tree;
-using Umbraco.Cms.Core.Models;
-using Umbraco.Cms.Core.Services;
-using Constants = Umbraco.Cms.Core.Constants;
-
-namespace Umbraco.Cms.Api.Management.Services.Flags;
-
-/// <summary>
-/// Implements a <see cref="IFlagProvider"/> that provides flags for documents that are scheduled for publication.
-/// </summary>
-internal class HasScheduleFlagProvider : IFlagProvider
-{
-    private const string Alias = Constants.Conventions.Flags.Prefix + "ScheduledForPublish";
-
-    private readonly IContentService _contentService;
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="HasScheduleFlagProvider"/> class.
-    /// </summary>
-    public HasScheduleFlagProvider(IContentService contentService)
-    {
-        _contentService = contentService;
-    }
-
-    /// <inheritdoc/>
-    public bool CanProvideFlags<TItem>()
-        where TItem : IHasFlags =>
-        typeof(TItem) == typeof(DocumentTreeItemResponseModel) ||
-        typeof(TItem) == typeof(DocumentCollectionResponseModel) ||
-        typeof(TItem) == typeof(DocumentItemResponseModel);
-
-    /// <inheritdoc/>
-    public Task PopulateFlagsAsync<TItem>(IEnumerable<TItem> items)
-        where TItem : IHasFlags
-    {
-        TItem[] itemsArray = items.ToArray();
-        IDictionary<Guid, IEnumerable<ContentSchedule>> schedules = _contentService.GetContentSchedulesByKeys(itemsArray.Select(x => x.Id).ToArray());
-        foreach (TItem item in itemsArray)
-        {
-            if (schedules.TryGetValue(item.Id, out IEnumerable<ContentSchedule>? contentSchedules) is false)
-            {
-                continue;
-            }
-
-            switch (item)
-            {
-                case DocumentTreeItemResponseModel documentTreeItemResponseModel:
-                    documentTreeItemResponseModel.Variants = PopulateVariants(documentTreeItemResponseModel.Variants, contentSchedules);
-                    break;
-
-                case DocumentCollectionResponseModel documentCollectionResponseModel:
-                    documentCollectionResponseModel.Variants = PopulateVariants(documentCollectionResponseModel.Variants, contentSchedules);
-                    break;
-
-                case DocumentItemResponseModel documentItemResponseModel:
-                    documentItemResponseModel.Variants = PopulateVariants(documentItemResponseModel.Variants, contentSchedules);
-                    break;
-            }
-        }
-
-        return Task.CompletedTask;
-    }
-
-    private IEnumerable<DocumentVariantItemResponseModel> PopulateVariants(
-        IEnumerable<DocumentVariantItemResponseModel> variants, IEnumerable<ContentSchedule> schedules)
-    {
-        DocumentVariantItemResponseModel[] variantsArray = variants.ToArray();
-        if (variantsArray.Length == 1)
-        {
-            DocumentVariantItemResponseModel variant = variantsArray[0];
-            variant.AddFlag(Alias);
-            return variantsArray;
-        }
-
-        foreach (DocumentVariantItemResponseModel variant in variantsArray)
-        {
-            ContentSchedule? schedule = schedules.FirstOrDefault(x => x.Culture == variant.Culture);
-            bool isScheduled = schedule != null && schedule.Date > DateTime.Now && string.Equals(schedule.Culture, variant.Culture);
-
-            if (isScheduled)
-            {
-                variant.AddFlag(Alias);
-            }
-        }
-
-        return variantsArray;
-    }
-
-    private IEnumerable<DocumentVariantResponseModel> PopulateVariants(
-        IEnumerable<DocumentVariantResponseModel> variants, IEnumerable<ContentSchedule> schedules)
-    {
-        DocumentVariantResponseModel[] variantsArray = variants.ToArray();
-        if (variantsArray.Length == 1)
-        {
-            DocumentVariantResponseModel variant = variantsArray[0];
-            variant.AddFlag(Alias);
-            return variantsArray;
-        }
-
-        foreach (DocumentVariantResponseModel variant in variantsArray)
-        {
-            ContentSchedule? schedule = schedules.FirstOrDefault(x => x.Culture == variant.Culture);
-            bool isScheduled = schedule != null && schedule.Date > DateTime.Now && string.Equals(schedule.Culture, variant.Culture);
-
-            if (isScheduled)
-            {
-                variant.AddFlag(Alias);
-            }
-        }
-
-        return variantsArray;
-    }
-}
diff --git a/src/Umbraco.Cms.Api.Management/Services/Flags/HasScheduleFlagProviderBase.cs b/src/Umbraco.Cms.Api.Management/Services/Flags/HasScheduleFlagProviderBase.cs
new file mode 100644
index 000000000000..d5a1da4185c5
--- /dev/null
+++ b/src/Umbraco.Cms.Api.Management/Services/Flags/HasScheduleFlagProviderBase.cs
@@ -0,0 +1,85 @@
+using Umbraco.Cms.Api.Management.ViewModels;
+using Umbraco.Cms.Core.Models;
+using Constants = Umbraco.Cms.Core.Constants;
+
+namespace Umbraco.Cms.Api.Management.Services.Flags;
+
+/// <summary>
+/// Base class for flag providers that add a "scheduled for publish" flag to items with active release schedules.
+/// </summary>
+internal abstract class HasScheduleFlagProviderBase : IFlagProvider
+{
+    protected const string Alias = Constants.Conventions.Flags.Prefix + "ScheduledForPublish";
+
+    private readonly TimeProvider _timeProvider;
+
+    protected HasScheduleFlagProviderBase(TimeProvider timeProvider)
+    {
+        _timeProvider = timeProvider;
+    }
+
+    /// <inheritdoc/>
+    public abstract bool CanProvideFlags<TItem>()
+        where TItem : IHasFlags;
+
+    /// <inheritdoc/>
+    public Task PopulateFlagsAsync<TItem>(IEnumerable<TItem> items)
+        where TItem : IHasFlags
+    {
+        TItem[] itemsArray = items.ToArray();
+        Guid[] keys = itemsArray.Select(i => i.Id).ToArray();
+        IDictionary<Guid, IEnumerable<ContentSchedule>> schedulesByKey = GetSchedulesByKeys(keys);
+
+        foreach (TItem item in itemsArray)
+        {
+            if (!schedulesByKey.TryGetValue(item.Id, out IEnumerable<ContentSchedule>? schedules))
+            {
+                continue;
+            }
+
+            ContentSchedule[] releaseSchedules = schedules
+                .Where(s => s.Action == ContentScheduleAction.Release)
+                .ToArray();
+
+            if (releaseSchedules.Length == 0)
+            {
+                continue;
+            }
+
+            PopulateItemFlags(item, releaseSchedules);
+        }
+
+        return Task.CompletedTask;
+    }
+
+    protected abstract IDictionary<Guid, IEnumerable<ContentSchedule>> GetSchedulesByKeys(Guid[] keys);
+
+    protected abstract void PopulateItemFlags<TItem>(TItem item, ContentSchedule[] releaseSchedules)
+        where TItem : IHasFlags;
+
+    protected IEnumerable<TVariant> PopulateVariants<TVariant>(
+        IEnumerable<TVariant> variants,
+        ContentSchedule[] schedules,
+        Func<TVariant, string?> getCulture)
+        where TVariant : IHasFlags
+    {
+        TVariant[] variantsArray = variants.ToArray();
+        if (variantsArray.Length == 1)
+        {
+            variantsArray[0].AddFlag(Alias);
+            return variantsArray;
+        }
+
+        foreach (TVariant variant in variantsArray)
+        {
+            var culture = getCulture(variant);
+            ContentSchedule? schedule = schedules.FirstOrDefault(x => x.Culture == culture);
+            if (schedule is not null && schedule.Date > _timeProvider.GetUtcNow().UtcDateTime && string.Equals(schedule.Culture, culture))
+            {
+                variant.AddFlag(Alias);
+            }
+        }
+
+        return variantsArray;
+    }
+}
diff --git a/src/Umbraco.Cms.Api.Management/ViewModels/Content/PublishableVariantItemResponseModelBase.cs b/src/Umbraco.Cms.Api.Management/ViewModels/Content/PublishableVariantItemResponseModelBase.cs
new file mode 100644
index 000000000000..942bcfd2015c
--- /dev/null
+++ b/src/Umbraco.Cms.Api.Management/ViewModels/Content/PublishableVariantItemResponseModelBase.cs
@@ -0,0 +1,36 @@
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+
+namespace Umbraco.Cms.Api.Management.ViewModels.Content;
+
+/// <summary>
+/// Base class for publishable variant item response models, providing flag support and publish state.
+/// </summary>
+public abstract class PublishableVariantItemResponseModelBase : VariantItemResponseModelBase, IHasFlags
+{
+    private readonly List<FlagModel> _flags = [];
+
+    /// <inheritdoc />
+    public Guid Id { get; }
+
+    /// <inheritdoc />
+    public IEnumerable<FlagModel> Flags
+    {
+        get => _flags.AsEnumerable();
+        set
+        {
+            _flags.Clear();
+            _flags.AddRange(value);
+        }
+    }
+
+    /// <inheritdoc />
+    public void AddFlag(string alias) => _flags.Add(new FlagModel { Alias = alias });
+
+    /// <inheritdoc />
+    public void RemoveFlag(string alias) => _flags.RemoveAll(x => x.Alias == alias);
+
+    /// <summary>
+    /// Gets or sets the publish state of the variant.
+    /// </summary>
+    public required DocumentVariantState State { get; set; }
+}
diff --git a/src/Umbraco.Cms.Api.Management/ViewModels/Content/PublishableVariantResponseModelBase.cs b/src/Umbraco.Cms.Api.Management/ViewModels/Content/PublishableVariantResponseModelBase.cs
index 18c7f95a195b..bbe10df06af5 100644
--- a/src/Umbraco.Cms.Api.Management/ViewModels/Content/PublishableVariantResponseModelBase.cs
+++ b/src/Umbraco.Cms.Api.Management/ViewModels/Content/PublishableVariantResponseModelBase.cs
@@ -2,13 +2,50 @@
 
 namespace Umbraco.Cms.Api.Management.ViewModels.Content;
 
-public abstract class PublishableVariantResponseModelBase : VariantResponseModelBase
+/// <summary>
+/// Base class for publishable variant response models, providing flag support, publish state, and scheduling information.
+/// </summary>
+public abstract class PublishableVariantResponseModelBase : VariantResponseModelBase, IHasFlags
 {
+    private readonly List<FlagModel> _flags = [];
+
+    /// <inheritdoc />
+    public Guid Id { get; }
+
+    /// <inheritdoc />
+    public IEnumerable<FlagModel> Flags
+    {
+        get => _flags.AsEnumerable();
+        set
+        {
+            _flags.Clear();
+            _flags.AddRange(value);
+        }
+    }
+
+    /// <inheritdoc />
+    public void AddFlag(string alias) => _flags.Add(new FlagModel { Alias = alias });
+
+    /// <inheritdoc />
+    public void RemoveFlag(string alias) => _flags.RemoveAll(x => x.Alias == alias);
+
+    /// <summary>
+    /// Gets or sets the publish state of the variant.
+    /// </summary>
     public DocumentVariantState State { get; set; }
 
+    /// <summary>
+    /// Gets or sets the date the variant was published.
+    /// </summary>
     public DateTimeOffset? PublishDate { get; set; }
 
+    /// <summary>
+    /// Gets or sets the scheduled publish date for the variant.
+    /// </summary>
     public DateTimeOffset? ScheduledPublishDate { get; set; }
 
+    /// <summary>
+    /// Gets or sets the scheduled unpublish date for the variant.
+    /// </summary>
     public DateTimeOffset? ScheduledUnpublishDate { get; set; }
 }
diff --git a/src/Umbraco.Cms.Api.Management/ViewModels/Document/DocumentVariantItemResponseModel.cs b/src/Umbraco.Cms.Api.Management/ViewModels/Document/DocumentVariantItemResponseModel.cs
index 22ad166f3fe5..9ff5e19c4805 100644
--- a/src/Umbraco.Cms.Api.Management/ViewModels/Document/DocumentVariantItemResponseModel.cs
+++ b/src/Umbraco.Cms.Api.Management/ViewModels/Document/DocumentVariantItemResponseModel.cs
@@ -6,37 +6,6 @@ namespace Umbraco.Cms.Api.Management.ViewModels.Document;
 /// Represents a response model for a document variant item in the Umbraco CMS Management API.
 /// A document variant typically refers to a specific language or segment version of a document.
 /// </summary>
-public class DocumentVariantItemResponseModel : VariantItemResponseModelBase, IHasFlags
+public class DocumentVariantItemResponseModel : PublishableVariantItemResponseModelBase
 {
-    private readonly List<FlagModel> _flags = [];
-
-    /// <summary>
-    /// Gets the unique identifier of the document variant.
-    /// </summary>
-    public Guid Id { get; }
-
-    /// <summary>
-    /// Gets or sets the collection of flags associated with the document variant.
-    /// </summary>
-    public IEnumerable<FlagModel> Flags
-    {
-        get => _flags.AsEnumerable();
-        set
-        {
-            _flags.Clear();
-            _flags.AddRange(value);
-        }
-    }
-
-    /// <summary>
-    /// Adds a flag with the specified alias to the collection of flags for this document variant.
-    /// </summary>
-    /// <param name="alias">The alias of the flag to add.</param>
-    public void AddFlag(string alias) => _flags.Add(new FlagModel { Alias = alias });
-
-    /// <summary>Removes a flag with the specified alias from the document variant.</summary>
-    /// <param name="alias">The alias of the flag to remove.</param>
-    public void RemoveFlag(string alias) => _flags.RemoveAll(x => x.Alias == alias);
-
-    public required DocumentVariantState State { get; set; }
 }
diff --git a/src/Umbraco.Cms.Api.Management/ViewModels/Document/DocumentVariantResponseModel.cs b/src/Umbraco.Cms.Api.Management/ViewModels/Document/DocumentVariantResponseModel.cs
index d6a3e62d7d37..02f1dba4bc6e 100644
--- a/src/Umbraco.Cms.Api.Management/ViewModels/Document/DocumentVariantResponseModel.cs
+++ b/src/Umbraco.Cms.Api.Management/ViewModels/Document/DocumentVariantResponseModel.cs
@@ -5,37 +5,6 @@ namespace Umbraco.Cms.Api.Management.ViewModels.Document;
 /// <summary>
 /// Represents the response model returned by the API for a specific variant of a document, containing variant-specific data.
 /// </summary>
-public class DocumentVariantResponseModel : PublishableVariantResponseModelBase, IHasFlags
+public class DocumentVariantResponseModel : PublishableVariantResponseModelBase
 {
-    private readonly List<FlagModel> _flags = [];
-
-    /// <summary>
-    /// Gets the unique identifier of the document variant.
-    /// </summary>
-    public Guid Id { get; }
-
-    /// <summary>
-    /// Gets or sets the collection of flags that provide additional information or status about the document variant.
-    /// </summary>
-    public IEnumerable<FlagModel> Flags
-    {
-        get => _flags.AsEnumerable();
-        set
-        {
-            _flags.Clear();
-            _flags.AddRange(value);
-        }
-    }
-
-    /// <summary>
-    /// Adds a flag with the specified alias to the current document variant.
-    /// </summary>
-    /// <param name="alias">The alias of the flag to add to the document variant.</param>
-    public void AddFlag(string alias) => _flags.Add(new FlagModel { Alias = alias });
-
-    /// <summary>
-    /// Removes a flag identified by the specified alias.
-    /// </summary>
-    /// <param name="alias">The alias of the flag to remove.</param>
-    public void RemoveFlag(string alias) => _flags.RemoveAll(x => x.Alias == alias);
 }
diff --git a/src/Umbraco.Cms.Api.Management/ViewModels/Element/ElementVariantItemResponseModel.cs b/src/Umbraco.Cms.Api.Management/ViewModels/Element/ElementVariantItemResponseModel.cs
index 1875775c7bd6..f7e77dfab9df 100644
--- a/src/Umbraco.Cms.Api.Management/ViewModels/Element/ElementVariantItemResponseModel.cs
+++ b/src/Umbraco.Cms.Api.Management/ViewModels/Element/ElementVariantItemResponseModel.cs
@@ -1,15 +1,10 @@
-using Umbraco.Cms.Api.Management.ViewModels.Content;
-using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Api.Management.ViewModels.Content;
 
 namespace Umbraco.Cms.Api.Management.ViewModels.Element;
 
 /// <summary>
 /// Represents a variant item response model for an element, including its publish state.
 /// </summary>
-public class ElementVariantItemResponseModel : VariantItemResponseModelBase
+public class ElementVariantItemResponseModel : PublishableVariantItemResponseModelBase
 {
-    /// <summary>
-    /// Gets or sets the publish state of the element variant.
-    /// </summary>
-    public required DocumentVariantState State { get; set; }
 }
diff --git a/src/Umbraco.Cms.Api.Management/ViewModels/Indexer/IndexResponseModel.cs b/src/Umbraco.Cms.Api.Management/ViewModels/Indexer/IndexResponseModel.cs
index 62debcf0b4af..a9bf40003fa0 100644
--- a/src/Umbraco.Cms.Api.Management/ViewModels/Indexer/IndexResponseModel.cs
+++ b/src/Umbraco.Cms.Api.Management/ViewModels/Indexer/IndexResponseModel.cs
@@ -46,4 +46,10 @@ public class IndexResponseModel
     /// The properties are represented as key-value pairs.
     /// </summary>
     public IReadOnlyDictionary<string, object?>? ProviderProperties { get; init; }
+
+    /// <summary>
+    /// Gets the name of the index field that contains the unique entity key (GUID).
+    /// Used by the backoffice Examine dashboard to construct edit links for search results.
+    /// </summary>
+    public string? UniqueKeyFieldName { get; init; }
 }
diff --git a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/DtoCustomization/SqlServerNodeDtoModelCustomizer.cs b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/DtoCustomization/SqlServerNodeDtoModelCustomizer.cs
new file mode 100644
index 000000000000..7f854824fb51
--- /dev/null
+++ b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/DtoCustomization/SqlServerNodeDtoModelCustomizer.cs
@@ -0,0 +1,44 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore;
+using Umbraco.Cms.Infrastructure.Persistence.EFCore;
+
+namespace Umbraco.Cms.Persistence.EFCore.SqlServer.DtoCustomization;
+
+/// <summary>
+/// Adds SQL Server-specific included columns to <see cref="NodeDto"/> indexes.
+/// </summary>
+public class SqlServerNodeDtoModelCustomizer : IEFCoreModelCustomizer<NodeDto>
+{
+    public string? ProviderName => Constants.ProviderNames.SQLServer;
+
+    public void Customize(EntityTypeBuilder<NodeDto> builder)
+    {
+        // IX_umbracoNode_UniqueId
+        builder.HasIndex(x => x.UniqueId)
+            .IsUnique()
+            .HasDatabaseName($"IX_{NodeDto.TableName}_UniqueId")
+            .IncludeProperties(x => new { x.ParentId, x.Level, x.Path, x.SortOrder, x.Trashed, x.UserId, x.Text, x.CreateDate });
+
+        // IX_umbracoNode_parentId_nodeObjectType
+        builder.HasIndex(x => new { x.ParentId, x.NodeObjectType })
+            .HasDatabaseName($"IX_{NodeDto.TableName}_parentId_nodeObjectType")
+            .IncludeProperties(x => new { x.Trashed, x.UserId, x.Level, x.Path, x.SortOrder, x.UniqueId, x.Text, x.CreateDate });
+
+        // IX_umbracoNode_Level
+        builder.HasIndex(x => new { x.Level, x.ParentId, x.SortOrder, x.NodeObjectType, x.Trashed })
+            .HasDatabaseName($"IX_{NodeDto.TableName}_Level")
+            .IncludeProperties(x => new { x.UserId, x.Path, x.UniqueId, x.CreateDate });
+
+        // IX_umbracoNode_ObjectType_trashed_sorted
+        builder.HasIndex(x => new { x.NodeObjectType, x.Trashed, x.SortOrder, x.NodeId })
+            .HasDatabaseName($"IX_{NodeDto.TableName}_ObjectType_trashed_sorted")
+            .IncludeProperties(x => new { x.UniqueId, x.ParentId, x.Level, x.Path, x.UserId, x.Text, x.CreateDate });
+
+        // IX_umbracoNode_ObjectType
+        builder.HasIndex(x => new { x.NodeObjectType, x.Trashed })
+            .HasDatabaseName($"IX_{NodeDto.TableName}_ObjectType")
+            .IncludeProperties(x => new { x.UniqueId, x.ParentId, x.Level, x.Path, x.SortOrder, x.UserId, x.Text, x.CreateDate });
+    }
+}
diff --git a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/Migrations/20260326120314_AddDomainDto.Designer.cs b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/Migrations/20260326120314_AddDomainDto.Designer.cs
new file mode 100644
index 000000000000..ea0b7778a885
--- /dev/null
+++ b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/Migrations/20260326120314_AddDomainDto.Designer.cs
@@ -0,0 +1,684 @@
+// <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 Umbraco.Cms.Infrastructure.Persistence.EFCore;
+
+#nullable disable
+
+namespace Umbraco.Cms.Persistence.EFCore.SqlServer.Migrations
+{
+    [DbContext(typeof(UmbracoDbContext))]
+    [Migration("20260326120314_AddDomainDto")]
+    partial class AddDomainDto
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.5")
+                .HasAnnotation("Relational:MaxIdentifierLength", 128);
+
+            SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ApplicationType")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ClientId")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("ClientSecret")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("ClientType")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ConcurrencyToken")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("ConsentType")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DisplayNames")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("JsonWebKeySet")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Permissions")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("PostLogoutRedirectUris")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("RedirectUris")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Requirements")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId")
+                        .IsUnique()
+                        .HasFilter("[ClientId] IS NOT NULL");
+
+                    b.ToTable("umbracoOpenIddictApplications", (string)null);
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ApplicationId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyToken")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<DateTime?>("CreationDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Scopes")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Status")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Subject")
+                        .HasMaxLength(400)
+                        .HasColumnType("nvarchar(400)");
+
+                    b.Property<string>("Type")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId", "Status", "Subject", "Type");
+
+                    b.ToTable("umbracoOpenIddictAuthorizations", (string)null);
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreScope", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyToken")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Descriptions")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("DisplayNames")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(200)
+                        .HasColumnType("nvarchar(200)");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Resources")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique()
+                        .HasFilter("[Name] IS NOT NULL");
+
+                    b.ToTable("umbracoOpenIddictScopes", (string)null);
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreToken", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ApplicationId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("AuthorizationId")
+                        .HasColumnType("nvarchar(450)");
+
+                    b.Property<string>("ConcurrencyToken")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<DateTime?>("CreationDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<DateTime?>("ExpirationDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("nvarchar(max)");
+
+                    b.Property<DateTime?>("RedemptionDate")
+                        .HasColumnType("datetime2");
+
+                    b.Property<string>("ReferenceId")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)");
+
+                    b.Property<string>("Status")
+                        .HasMaxLength(50)
+                        .HasColumnType("nvarchar(50)");
+
+                    b.Property<string>("Subject")
+                        .HasMaxLength(400)
+                        .HasColumnType("nvarchar(400)");
+
+                    b.Property<string>("Type")
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuthorizationId");
+
+                    b.HasIndex("ReferenceId")
+                        .IsUnique()
+                        .HasFilter("[ReferenceId] IS NOT NULL");
+
+                    b.HasIndex("ApplicationId", "Status", "Subject", "Type");
+
+                    b.ToTable("umbracoOpenIddictTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.CacheInstructionDto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasColumnName("id");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("InstructionCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasDefaultValue(1)
+                        .HasColumnName("instructionCount");
+
+                    b.Property<string>("Instructions")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("jsonInstruction");
+
+                    b.Property<string>("OriginIdentity")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("nvarchar(500)")
+                        .HasColumnName("originated");
+
+                    b.Property<DateTime>("UtcStamp")
+                        .HasColumnType("datetime2")
+                        .HasColumnName("utcStamp");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("umbracoCacheInstruction", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.DomainDto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasColumnName("id");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("DefaultLanguage")
+                        .HasColumnType("int")
+                        .HasColumnName("domainDefaultLanguage");
+
+                    b.Property<string>("DomainName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("domainName");
+
+                    b.Property<Guid>("Key")
+                        .HasColumnType("uniqueidentifier")
+                        .HasColumnName("key");
+
+                    b.Property<int?>("RootStructureId")
+                        .HasColumnType("int")
+                        .HasColumnName("domainRootStructureID");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int")
+                        .HasColumnName("sortOrder");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key")
+                        .IsUnique();
+
+                    b.ToTable("umbracoDomain", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.KeyValueDto", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("nvarchar(256)")
+                        .HasColumnName("key");
+
+                    b.Property<DateTime>("UpdateDate")
+                        .HasColumnType("datetime2")
+                        .HasColumnName("updated");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("value");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("umbracoKeyValue", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.LanguageDto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasColumnName("id");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("CultureName")
+                        .HasMaxLength(100)
+                        .HasColumnType("nvarchar(100)")
+                        .HasColumnName("languageCultureName");
+
+                    b.Property<int?>("FallbackLanguageId")
+                        .HasColumnType("int")
+                        .HasColumnName("fallbackLanguageId");
+
+                    b.Property<bool>("IsDefault")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false)
+                        .HasColumnName("isDefaultVariantLang");
+
+                    b.Property<bool>("IsMandatory")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false)
+                        .HasColumnName("mandatory");
+
+                    b.Property<string>("IsoCode")
+                        .HasMaxLength(14)
+                        .HasColumnType("nvarchar(14)")
+                        .HasColumnName("languageISOCode");
+
+                    b.Property<Guid>("LanguageKey")
+                        .HasColumnType("uniqueidentifier")
+                        .HasColumnName("languageKey");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FallbackLanguageId");
+
+                    b.HasIndex("IsoCode")
+                        .IsUnique()
+                        .HasFilter("[languageISOCode] IS NOT NULL");
+
+                    b.HasIndex("LanguageKey")
+                        .IsUnique();
+
+                    b.ToTable("umbracoLanguage", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.LastSyncedDto", b =>
+                {
+                    b.Property<string>("MachineId")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("machineId");
+
+                    b.Property<DateTime>("LastSyncedDate")
+                        .HasColumnType("datetime2")
+                        .HasColumnName("lastSyncedDate");
+
+                    b.Property<int?>("LastSyncedExternalId")
+                        .HasColumnType("int");
+
+                    b.Property<int?>("LastSyncedInternalId")
+                        .HasColumnType("int")
+                        .HasColumnName("lastSyncedInternalId");
+
+                    b.HasKey("MachineId");
+
+                    b.ToTable("umbracoLastSynced", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", b =>
+                {
+                    b.Property<int>("NodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasColumnName("id");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("NodeId"));
+
+                    b.Property<DateTime>("CreateDate")
+                        .HasColumnType("datetime2")
+                        .HasColumnName("createDate");
+
+                    b.Property<short>("Level")
+                        .HasColumnType("smallint")
+                        .HasColumnName("level");
+
+                    b.Property<Guid?>("NodeObjectType")
+                        .HasColumnType("uniqueidentifier")
+                        .HasColumnName("nodeObjectType");
+
+                    b.Property<int>("ParentId")
+                        .HasColumnType("int")
+                        .HasColumnName("parentId");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)")
+                        .HasColumnName("path");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int")
+                        .HasColumnName("sortOrder");
+
+                    b.Property<string>("Text")
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("text");
+
+                    b.Property<bool>("Trashed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false)
+                        .HasColumnName("trashed");
+
+                    b.Property<Guid>("UniqueId")
+                        .HasColumnType("uniqueidentifier")
+                        .HasColumnName("uniqueId");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int")
+                        .HasColumnName("nodeUser");
+
+                    b.HasKey("NodeId");
+
+                    b.HasIndex("Path")
+                        .HasDatabaseName("IX_umbracoNode_Path");
+
+                    b.HasIndex("Trashed")
+                        .HasDatabaseName("IX_umbracoNode_Trashed");
+
+                    b.HasIndex("UniqueId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_umbracoNode_UniqueId");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("UniqueId"), new[] { "ParentId", "Level", "Path", "SortOrder", "Trashed", "UserId", "Text", "CreateDate" });
+
+                    b.HasIndex("NodeObjectType", "Trashed")
+                        .HasDatabaseName("IX_umbracoNode_ObjectType");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("NodeObjectType", "Trashed"), new[] { "UniqueId", "ParentId", "Level", "Path", "SortOrder", "UserId", "Text", "CreateDate" });
+
+                    b.HasIndex("ParentId", "NodeObjectType")
+                        .HasDatabaseName("IX_umbracoNode_parentId_nodeObjectType");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("ParentId", "NodeObjectType"), new[] { "Trashed", "UserId", "Level", "Path", "SortOrder", "UniqueId", "Text", "CreateDate" });
+
+                    b.HasIndex("NodeObjectType", "Trashed", "SortOrder", "NodeId")
+                        .HasDatabaseName("IX_umbracoNode_ObjectType_trashed_sorted");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("NodeObjectType", "Trashed", "SortOrder", "NodeId"), new[] { "UniqueId", "ParentId", "Level", "Path", "UserId", "Text", "CreateDate" });
+
+                    b.HasIndex("Level", "ParentId", "SortOrder", "NodeObjectType", "Trashed")
+                        .HasDatabaseName("IX_umbracoNode_Level");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("Level", "ParentId", "SortOrder", "NodeObjectType", "Trashed"), new[] { "UserId", "Path", "UniqueId", "CreateDate" });
+
+                    b.ToTable("umbracoNode", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2ContentTypeKeysDto", b =>
+                {
+                    b.Property<int>("WebhookId")
+                        .HasColumnType("int")
+                        .HasColumnName("webhookId");
+
+                    b.Property<Guid>("ContentTypeKey")
+                        .HasColumnType("uniqueidentifier")
+                        .HasColumnName("entityKey");
+
+                    b.HasKey("WebhookId", "ContentTypeKey")
+                        .HasName("PK_webhookEntityKey2Webhook");
+
+                    b.ToTable("umbracoWebhook2ContentTypeKeys", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2EventsDto", b =>
+                {
+                    b.Property<int>("WebhookId")
+                        .HasColumnType("int")
+                        .HasColumnName("webhookId");
+
+                    b.Property<string>("Event")
+                        .HasMaxLength(255)
+                        .HasColumnType("nvarchar(255)")
+                        .HasColumnName("event");
+
+                    b.HasKey("WebhookId", "Event")
+                        .HasName("PK_webhookEvent2WebhookDto");
+
+                    b.ToTable("umbracoWebhook2Events", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2HeadersDto", b =>
+                {
+                    b.Property<int>("WebhookId")
+                        .HasColumnType("int")
+                        .HasColumnName("webhookId");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("nvarchar(450)")
+                        .HasColumnName("Key");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)");
+
+                    b.HasKey("WebhookId", "Key")
+                        .HasName("PK_headers2WebhookDto");
+
+                    b.ToTable("umbracoWebhook2Headers", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasColumnName("id");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("description");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("bit")
+                        .HasColumnName("enabled");
+
+                    b.Property<Guid>("Key")
+                        .HasColumnType("uniqueidentifier")
+                        .HasColumnName("key");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("name");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("url");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("umbracoWebhook", (string)null);
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
+                {
+                    b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", "Application")
+                        .WithMany("Authorizations")
+                        .HasForeignKey("ApplicationId");
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreToken", b =>
+                {
+                    b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", "Application")
+                        .WithMany("Tokens")
+                        .HasForeignKey("ApplicationId");
+
+                    b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", "Authorization")
+                        .WithMany("Tokens")
+                        .HasForeignKey("AuthorizationId");
+
+                    b.Navigation("Application");
+
+                    b.Navigation("Authorization");
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.LanguageDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.LanguageDto", "FallbackLanguage")
+                        .WithMany()
+                        .HasForeignKey("FallbackLanguageId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("FallbackLanguage");
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", null)
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2ContentTypeKeysDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", "Webhook")
+                        .WithMany("Webhook2ContentTypeKeys")
+                        .HasForeignKey("WebhookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Webhook");
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2EventsDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", "Webhook")
+                        .WithMany("Webhook2Events")
+                        .HasForeignKey("WebhookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Webhook");
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2HeadersDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", "Webhook")
+                        .WithMany("Webhook2Headers")
+                        .HasForeignKey("WebhookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Webhook");
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", b =>
+                {
+                    b.Navigation("Authorizations");
+
+                    b.Navigation("Tokens");
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
+                {
+                    b.Navigation("Tokens");
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", b =>
+                {
+                    b.Navigation("Webhook2ContentTypeKeys");
+
+                    b.Navigation("Webhook2Events");
+
+                    b.Navigation("Webhook2Headers");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/Migrations/20260326120314_AddDomainDto.cs b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/Migrations/20260326120314_AddDomainDto.cs
new file mode 100644
index 000000000000..a48c9e4c7e3a
--- /dev/null
+++ b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/Migrations/20260326120314_AddDomainDto.cs
@@ -0,0 +1,21 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Umbraco.Cms.Persistence.EFCore.SqlServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddDomainDto : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+        }
+    }
+}
diff --git a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/Migrations/UmbracoDbContextModelSnapshot.cs b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/Migrations/UmbracoDbContextModelSnapshot.cs
index 0464c3b88e7c..98db50aa81dc 100644
--- a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/Migrations/UmbracoDbContextModelSnapshot.cs
+++ b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/Migrations/UmbracoDbContextModelSnapshot.cs
@@ -17,7 +17,7 @@ protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
             modelBuilder
-                .HasAnnotation("ProductVersion", "10.0.2")
+                .HasAnnotation("ProductVersion", "10.0.5")
                 .HasAnnotation("Relational:MaxIdentifierLength", 128);
 
             SqlServerModelBuilderExtensions.UseIdentityColumns(modelBuilder);
@@ -268,6 +268,44 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("umbracoCacheInstruction", (string)null);
                 });
 
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.DomainDto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasColumnName("id");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("Id"));
+
+                    b.Property<int?>("DefaultLanguage")
+                        .HasColumnType("int")
+                        .HasColumnName("domainDefaultLanguage");
+
+                    b.Property<string>("DomainName")
+                        .IsRequired()
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("domainName");
+
+                    b.Property<Guid>("Key")
+                        .HasColumnType("uniqueidentifier")
+                        .HasColumnName("key");
+
+                    b.Property<int?>("RootStructureId")
+                        .HasColumnType("int")
+                        .HasColumnName("domainRootStructureID");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int")
+                        .HasColumnName("sortOrder");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key")
+                        .IsUnique();
+
+                    b.ToTable("umbracoDomain", (string)null);
+                });
+
             modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.KeyValueDto", b =>
                 {
                     b.Property<string>("Key")
@@ -363,6 +401,96 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("umbracoLastSynced", (string)null);
                 });
 
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", b =>
+                {
+                    b.Property<int>("NodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("int")
+                        .HasColumnName("id");
+
+                    SqlServerPropertyBuilderExtensions.UseIdentityColumn(b.Property<int>("NodeId"));
+
+                    b.Property<DateTime>("CreateDate")
+                        .HasColumnType("datetime2")
+                        .HasColumnName("createDate");
+
+                    b.Property<short>("Level")
+                        .HasColumnType("smallint")
+                        .HasColumnName("level");
+
+                    b.Property<Guid?>("NodeObjectType")
+                        .HasColumnType("uniqueidentifier")
+                        .HasColumnName("nodeObjectType");
+
+                    b.Property<int>("ParentId")
+                        .HasColumnType("int")
+                        .HasColumnName("parentId");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("nvarchar(150)")
+                        .HasColumnName("path");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("int")
+                        .HasColumnName("sortOrder");
+
+                    b.Property<string>("Text")
+                        .HasColumnType("nvarchar(max)")
+                        .HasColumnName("text");
+
+                    b.Property<bool>("Trashed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bit")
+                        .HasDefaultValue(false)
+                        .HasColumnName("trashed");
+
+                    b.Property<Guid>("UniqueId")
+                        .HasColumnType("uniqueidentifier")
+                        .HasColumnName("uniqueId");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("int")
+                        .HasColumnName("nodeUser");
+
+                    b.HasKey("NodeId");
+
+                    b.HasIndex("Path")
+                        .HasDatabaseName("IX_umbracoNode_Path");
+
+                    b.HasIndex("Trashed")
+                        .HasDatabaseName("IX_umbracoNode_Trashed");
+
+                    b.HasIndex("UniqueId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_umbracoNode_UniqueId");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("UniqueId"), new[] { "ParentId", "Level", "Path", "SortOrder", "Trashed", "UserId", "Text", "CreateDate" });
+
+                    b.HasIndex("NodeObjectType", "Trashed")
+                        .HasDatabaseName("IX_umbracoNode_ObjectType");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("NodeObjectType", "Trashed"), new[] { "UniqueId", "ParentId", "Level", "Path", "SortOrder", "UserId", "Text", "CreateDate" });
+
+                    b.HasIndex("ParentId", "NodeObjectType")
+                        .HasDatabaseName("IX_umbracoNode_parentId_nodeObjectType");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("ParentId", "NodeObjectType"), new[] { "Trashed", "UserId", "Level", "Path", "SortOrder", "UniqueId", "Text", "CreateDate" });
+
+                    b.HasIndex("NodeObjectType", "Trashed", "SortOrder", "NodeId")
+                        .HasDatabaseName("IX_umbracoNode_ObjectType_trashed_sorted");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("NodeObjectType", "Trashed", "SortOrder", "NodeId"), new[] { "UniqueId", "ParentId", "Level", "Path", "UserId", "Text", "CreateDate" });
+
+                    b.HasIndex("Level", "ParentId", "SortOrder", "NodeObjectType", "Trashed")
+                        .HasDatabaseName("IX_umbracoNode_Level");
+
+                    SqlServerIndexBuilderExtensions.IncludeProperties(b.HasIndex("Level", "ParentId", "SortOrder", "NodeObjectType", "Trashed"), new[] { "UserId", "Path", "UniqueId", "CreateDate" });
+
+                    b.ToTable("umbracoNode", (string)null);
+                });
+
             modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2ContentTypeKeysDto", b =>
                 {
                     b.Property<int>("WebhookId")
@@ -485,6 +613,15 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("FallbackLanguage");
                 });
 
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", null)
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2ContentTypeKeysDto", b =>
                 {
                     b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", "Webhook")
diff --git a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/SqlServerEFCoreDistributedLockingMechanism.cs b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/SqlServerEFCoreDistributedLockingMechanism.cs
index 7aa0cc8466d6..c70968cec7b6 100644
--- a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/SqlServerEFCoreDistributedLockingMechanism.cs
+++ b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/SqlServerEFCoreDistributedLockingMechanism.cs
@@ -137,7 +137,7 @@ public override string ToString()
 
         private void ObtainReadLock()
         {
-            IEfCoreScope<T>? scope = _parent._scopeAccessor.Value.AmbientScope;
+            IEFCoreScope<T>? scope = _parent._scopeAccessor.Value.AmbientScope;
 
             if (scope is null)
             {
@@ -171,7 +171,7 @@ private void ObtainReadLock()
 
         private void ObtainWriteLock()
         {
-            IEfCoreScope<T>? scope = _parent._scopeAccessor.Value.AmbientScope;
+            IEFCoreScope<T>? scope = _parent._scopeAccessor.Value.AmbientScope;
             if (scope is null)
             {
                 throw new PanicException("No ambient scope");
diff --git a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/SqlServerMigrationProvider.cs b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/SqlServerMigrationProvider.cs
index 2bba2c6ac5ac..bb1eedf33411 100644
--- a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/SqlServerMigrationProvider.cs
+++ b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/SqlServerMigrationProvider.cs
@@ -55,6 +55,7 @@ public async Task MigrateAllAsync()
             EFCoreMigration.AddKeyValueDto => typeof(Migrations.AddKeyValueDto),
             EFCoreMigration.SqliteCollation => null, // SQLite-only migration, no-op on SQL Server
             EFCoreMigration.AddLanguageDto => typeof(Migrations.AddLanguageDto),
+            EFCoreMigration.AddDomainDto => typeof(Migrations.AddDomainDto),
             _ => throw new ArgumentOutOfRangeException(nameof(migration), $@"Not expected migration value: {migration}")
         };
 }
diff --git a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/UmbracoBuilderExtensions.cs b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/UmbracoBuilderExtensions.cs
index e4554d76e0de..64c084f5773b 100644
--- a/src/Umbraco.Cms.Persistence.EFCore.SqlServer/UmbracoBuilderExtensions.cs
+++ b/src/Umbraco.Cms.Persistence.EFCore.SqlServer/UmbracoBuilderExtensions.cs
@@ -4,6 +4,7 @@
 using Umbraco.Cms.Infrastructure.Persistence.EFCore;
 using Umbraco.Cms.Infrastructure.Persistence.EFCore.Migrations;
 using Umbraco.Cms.Persistence.EFCore.Migrations;
+using Umbraco.Cms.Persistence.EFCore.SqlServer.DtoCustomization;
 using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Persistence.EFCore.SqlServer;
@@ -24,6 +25,11 @@ public static IUmbracoBuilder AddUmbracoEFCoreSqlServerSupport(this IUmbracoBuil
 
         builder.AddDbContextRegistrar<SqlServerDbContextServiceRegistrar>();
 
+        AddCustomizers(builder);
+
         return builder;
     }
+
+    private static void AddCustomizers(IUmbracoBuilder builder) =>
+        builder.AddEFCoreModelCustomizer<SqlServerNodeDtoModelCustomizer>();
 }
diff --git a/src/Umbraco.Cms.Persistence.EFCore.Sqlite/Migrations/20260326120231_AddDomainDto.Designer.cs b/src/Umbraco.Cms.Persistence.EFCore.Sqlite/Migrations/20260326120231_AddDomainDto.Designer.cs
new file mode 100644
index 000000000000..c52dc03f90ae
--- /dev/null
+++ b/src/Umbraco.Cms.Persistence.EFCore.Sqlite/Migrations/20260326120231_AddDomainDto.Designer.cs
@@ -0,0 +1,714 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Umbraco.Cms.Infrastructure.Persistence.EFCore;
+
+#nullable disable
+
+namespace Umbraco.Cms.Persistence.EFCore.Sqlite.Migrations
+{
+    [DbContext(typeof(UmbracoDbContext))]
+    [Migration("20260326120231_AddDomainDto")]
+    partial class AddDomainDto
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.5");
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ApplicationType")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ClientId")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ClientSecret")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ClientType")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ConcurrencyToken")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ConsentType")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("DisplayNames")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("JsonWebKeySet")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Permissions")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("PostLogoutRedirectUris")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("RedirectUris")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Requirements")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Settings")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId")
+                        .IsUnique();
+
+                    b.ToTable("umbracoOpenIddictApplications", (string)null);
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ApplicationId")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ConcurrencyToken")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<DateTime?>("CreationDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Scopes")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Status")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Subject")
+                        .HasMaxLength(400)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Type")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationId", "Status", "Subject", "Type");
+
+                    b.ToTable("umbracoOpenIddictAuthorizations", (string)null);
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreScope", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ConcurrencyToken")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Descriptions")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("DisplayNames")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(200)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Resources")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name")
+                        .IsUnique();
+
+                    b.ToTable("umbracoOpenIddictScopes", (string)null);
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreToken", b =>
+                {
+                    b.Property<string>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ApplicationId")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("AuthorizationId")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("ConcurrencyToken")
+                        .IsConcurrencyToken()
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<DateTime?>("CreationDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("ExpirationDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Payload")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Properties")
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<DateTime?>("RedemptionDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ReferenceId")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Status")
+                        .HasMaxLength(50)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Subject")
+                        .HasMaxLength(400)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Type")
+                        .HasMaxLength(150)
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuthorizationId");
+
+                    b.HasIndex("ReferenceId")
+                        .IsUnique();
+
+                    b.HasIndex("ApplicationId", "Status", "Subject", "Type");
+
+                    b.ToTable("umbracoOpenIddictTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.CacheInstructionDto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<int>("InstructionCount")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(1)
+                        .HasColumnName("instructionCount");
+
+                    b.Property<string>("Instructions")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("jsonInstruction")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("OriginIdentity")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("originated")
+                        .UseCollation("NOCASE");
+
+                    b.Property<DateTime>("UtcStamp")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("utcStamp");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("umbracoCacheInstruction", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.DomainDto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<int?>("DefaultLanguage")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("domainDefaultLanguage");
+
+                    b.Property<string>("DomainName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("domainName")
+                        .UseCollation("NOCASE");
+
+                    b.Property<Guid>("Key")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("key");
+
+                    b.Property<int?>("RootStructureId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("domainRootStructureID");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("sortOrder");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key")
+                        .IsUnique();
+
+                    b.ToTable("umbracoDomain", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.KeyValueDto", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("key")
+                        .UseCollation("NOCASE");
+
+                    b.Property<DateTime>("UpdateDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("updated");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("value")
+                        .UseCollation("NOCASE");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("umbracoKeyValue", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.LanguageDto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<string>("CultureName")
+                        .HasMaxLength(100)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("languageCultureName")
+                        .UseCollation("NOCASE");
+
+                    b.Property<int?>("FallbackLanguageId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("fallbackLanguageId");
+
+                    b.Property<bool>("IsDefault")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("isDefaultVariantLang");
+
+                    b.Property<bool>("IsMandatory")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("mandatory");
+
+                    b.Property<string>("IsoCode")
+                        .HasMaxLength(14)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("languageISOCode")
+                        .UseCollation("NOCASE");
+
+                    b.Property<Guid>("LanguageKey")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("languageKey");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FallbackLanguageId");
+
+                    b.HasIndex("IsoCode")
+                        .IsUnique();
+
+                    b.HasIndex("LanguageKey")
+                        .IsUnique();
+
+                    b.ToTable("umbracoLanguage", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.LastSyncedDto", b =>
+                {
+                    b.Property<string>("MachineId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("machineId")
+                        .UseCollation("NOCASE");
+
+                    b.Property<DateTime>("LastSyncedDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("lastSyncedDate");
+
+                    b.Property<int?>("LastSyncedExternalId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("LastSyncedInternalId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("lastSyncedInternalId");
+
+                    b.HasKey("MachineId");
+
+                    b.ToTable("umbracoLastSynced", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", b =>
+                {
+                    b.Property<int>("NodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreateDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("createDate");
+
+                    b.Property<short>("Level")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("level");
+
+                    b.Property<Guid?>("NodeObjectType")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("nodeObjectType");
+
+                    b.Property<int>("ParentId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("parentId");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("path")
+                        .UseCollation("NOCASE");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("sortOrder");
+
+                    b.Property<string>("Text")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("text")
+                        .UseCollation("NOCASE");
+
+                    b.Property<bool>("Trashed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("trashed");
+
+                    b.Property<Guid>("UniqueId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("uniqueId");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("nodeUser");
+
+                    b.HasKey("NodeId");
+
+                    b.HasIndex("Path")
+                        .HasDatabaseName("IX_umbracoNode_Path");
+
+                    b.HasIndex("Trashed")
+                        .HasDatabaseName("IX_umbracoNode_Trashed");
+
+                    b.HasIndex("UniqueId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_umbracoNode_UniqueId");
+
+                    b.HasIndex("NodeObjectType", "Trashed")
+                        .HasDatabaseName("IX_umbracoNode_ObjectType");
+
+                    b.HasIndex("ParentId", "NodeObjectType")
+                        .HasDatabaseName("IX_umbracoNode_parentId_nodeObjectType");
+
+                    b.HasIndex("NodeObjectType", "Trashed", "SortOrder", "NodeId")
+                        .HasDatabaseName("IX_umbracoNode_ObjectType_trashed_sorted");
+
+                    b.HasIndex("Level", "ParentId", "SortOrder", "NodeObjectType", "Trashed")
+                        .HasDatabaseName("IX_umbracoNode_Level");
+
+                    b.ToTable("umbracoNode", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2ContentTypeKeysDto", b =>
+                {
+                    b.Property<int>("WebhookId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("webhookId");
+
+                    b.Property<Guid>("ContentTypeKey")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("entityKey");
+
+                    b.HasKey("WebhookId", "ContentTypeKey")
+                        .HasName("PK_webhookEntityKey2Webhook");
+
+                    b.ToTable("umbracoWebhook2ContentTypeKeys", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2EventsDto", b =>
+                {
+                    b.Property<int>("WebhookId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("webhookId");
+
+                    b.Property<string>("Event")
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("event")
+                        .UseCollation("NOCASE");
+
+                    b.HasKey("WebhookId", "Event")
+                        .HasName("PK_webhookEvent2WebhookDto");
+
+                    b.ToTable("umbracoWebhook2Events", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2HeadersDto", b =>
+                {
+                    b.Property<int>("WebhookId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("webhookId");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("Key")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .UseCollation("NOCASE");
+
+                    b.HasKey("WebhookId", "Key")
+                        .HasName("PK_headers2WebhookDto");
+
+                    b.ToTable("umbracoWebhook2Headers", (string)null);
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("description")
+                        .UseCollation("NOCASE");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("enabled");
+
+                    b.Property<Guid>("Key")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("key");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("name")
+                        .UseCollation("NOCASE");
+
+                    b.Property<string>("Url")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("url")
+                        .UseCollation("NOCASE");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("umbracoWebhook", (string)null);
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
+                {
+                    b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", "Application")
+                        .WithMany("Authorizations")
+                        .HasForeignKey("ApplicationId");
+
+                    b.Navigation("Application");
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreToken", b =>
+                {
+                    b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", "Application")
+                        .WithMany("Tokens")
+                        .HasForeignKey("ApplicationId");
+
+                    b.HasOne("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", "Authorization")
+                        .WithMany("Tokens")
+                        .HasForeignKey("AuthorizationId");
+
+                    b.Navigation("Application");
+
+                    b.Navigation("Authorization");
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.LanguageDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.LanguageDto", "FallbackLanguage")
+                        .WithMany()
+                        .HasForeignKey("FallbackLanguageId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.Navigation("FallbackLanguage");
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", null)
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2ContentTypeKeysDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", "Webhook")
+                        .WithMany("Webhook2ContentTypeKeys")
+                        .HasForeignKey("WebhookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Webhook");
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2EventsDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", "Webhook")
+                        .WithMany("Webhook2Events")
+                        .HasForeignKey("WebhookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Webhook");
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2HeadersDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", "Webhook")
+                        .WithMany("Webhook2Headers")
+                        .HasForeignKey("WebhookId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Webhook");
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", b =>
+                {
+                    b.Navigation("Authorizations");
+
+                    b.Navigation("Tokens");
+                });
+
+            modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreAuthorization", b =>
+                {
+                    b.Navigation("Tokens");
+                });
+
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", b =>
+                {
+                    b.Navigation("Webhook2ContentTypeKeys");
+
+                    b.Navigation("Webhook2Events");
+
+                    b.Navigation("Webhook2Headers");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Umbraco.Cms.Persistence.EFCore.Sqlite/Migrations/20260326120231_AddDomainDto.cs b/src/Umbraco.Cms.Persistence.EFCore.Sqlite/Migrations/20260326120231_AddDomainDto.cs
new file mode 100644
index 000000000000..a6aa9359b4f5
--- /dev/null
+++ b/src/Umbraco.Cms.Persistence.EFCore.Sqlite/Migrations/20260326120231_AddDomainDto.cs
@@ -0,0 +1,21 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Umbraco.Cms.Persistence.EFCore.Sqlite.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddDomainDto : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+        }
+    }
+}
diff --git a/src/Umbraco.Cms.Persistence.EFCore.Sqlite/Migrations/UmbracoDbContextModelSnapshot.cs b/src/Umbraco.Cms.Persistence.EFCore.Sqlite/Migrations/UmbracoDbContextModelSnapshot.cs
index 237e00255f5f..4ff8b61e8c56 100644
--- a/src/Umbraco.Cms.Persistence.EFCore.Sqlite/Migrations/UmbracoDbContextModelSnapshot.cs
+++ b/src/Umbraco.Cms.Persistence.EFCore.Sqlite/Migrations/UmbracoDbContextModelSnapshot.cs
@@ -15,7 +15,7 @@ partial class UmbracoDbContextModelSnapshot : ModelSnapshot
         protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.5");
 
             modelBuilder.Entity("OpenIddict.EntityFrameworkCore.Models.OpenIddictEntityFrameworkCoreApplication", b =>
                 {
@@ -303,6 +303,43 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("umbracoCacheInstruction", (string)null);
                 });
 
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.DomainDto", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<int?>("DefaultLanguage")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("domainDefaultLanguage");
+
+                    b.Property<string>("DomainName")
+                        .IsRequired()
+                        .HasColumnType("TEXT")
+                        .HasColumnName("domainName")
+                        .UseCollation("NOCASE");
+
+                    b.Property<Guid>("Key")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("key");
+
+                    b.Property<int?>("RootStructureId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("domainRootStructureID");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("sortOrder");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Key")
+                        .IsUnique();
+
+                    b.ToTable("umbracoDomain", (string)null);
+                });
+
             modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.KeyValueDto", b =>
                 {
                     b.Property<string>("Key")
@@ -400,6 +437,86 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.ToTable("umbracoLastSynced", (string)null);
                 });
 
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", b =>
+                {
+                    b.Property<int>("NodeId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("id");
+
+                    b.Property<DateTime>("CreateDate")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("createDate");
+
+                    b.Property<short>("Level")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("level");
+
+                    b.Property<Guid?>("NodeObjectType")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("nodeObjectType");
+
+                    b.Property<int>("ParentId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("parentId");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(150)
+                        .HasColumnType("TEXT")
+                        .HasColumnName("path")
+                        .UseCollation("NOCASE");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("sortOrder");
+
+                    b.Property<string>("Text")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("text")
+                        .UseCollation("NOCASE");
+
+                    b.Property<bool>("Trashed")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER")
+                        .HasDefaultValue(false)
+                        .HasColumnName("trashed");
+
+                    b.Property<Guid>("UniqueId")
+                        .HasColumnType("TEXT")
+                        .HasColumnName("uniqueId");
+
+                    b.Property<int?>("UserId")
+                        .HasColumnType("INTEGER")
+                        .HasColumnName("nodeUser");
+
+                    b.HasKey("NodeId");
+
+                    b.HasIndex("Path")
+                        .HasDatabaseName("IX_umbracoNode_Path");
+
+                    b.HasIndex("Trashed")
+                        .HasDatabaseName("IX_umbracoNode_Trashed");
+
+                    b.HasIndex("UniqueId")
+                        .IsUnique()
+                        .HasDatabaseName("IX_umbracoNode_UniqueId");
+
+                    b.HasIndex("NodeObjectType", "Trashed")
+                        .HasDatabaseName("IX_umbracoNode_ObjectType");
+
+                    b.HasIndex("ParentId", "NodeObjectType")
+                        .HasDatabaseName("IX_umbracoNode_parentId_nodeObjectType");
+
+                    b.HasIndex("NodeObjectType", "Trashed", "SortOrder", "NodeId")
+                        .HasDatabaseName("IX_umbracoNode_ObjectType_trashed_sorted");
+
+                    b.HasIndex("Level", "ParentId", "SortOrder", "NodeObjectType", "Trashed")
+                        .HasDatabaseName("IX_umbracoNode_Level");
+
+                    b.ToTable("umbracoNode", (string)null);
+                });
+
             modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2ContentTypeKeysDto", b =>
                 {
                     b.Property<int>("WebhookId")
@@ -526,6 +643,15 @@ protected override void BuildModel(ModelBuilder modelBuilder)
                     b.Navigation("FallbackLanguage");
                 });
 
+            modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", b =>
+                {
+                    b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.NodeDto", null)
+                        .WithMany()
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+                });
+
             modelBuilder.Entity("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Webhook2ContentTypeKeysDto", b =>
                 {
                     b.HasOne("Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.WebhookDto", "Webhook")
diff --git a/src/Umbraco.Cms.Persistence.EFCore.Sqlite/SqliteEFCoreDistributedLockingMechanism.cs b/src/Umbraco.Cms.Persistence.EFCore.Sqlite/SqliteEFCoreDistributedLockingMechanism.cs
index 37e7565eeb08..293caefb849e 100644
--- a/src/Umbraco.Cms.Persistence.EFCore.Sqlite/SqliteEFCoreDistributedLockingMechanism.cs
+++ b/src/Umbraco.Cms.Persistence.EFCore.Sqlite/SqliteEFCoreDistributedLockingMechanism.cs
@@ -142,7 +142,7 @@ public override string ToString()
         // Mostly no-op just check that we didn't end up ReadUncommitted for real.
         private void ObtainReadLock()
         {
-            IEfCoreScope<T>? efCoreScope = _parent._efCoreScopeAccessor.Value.AmbientScope
+            IEFCoreScope<T>? efCoreScope = _parent._efCoreScopeAccessor.Value.AmbientScope
                 ?? throw new PanicException("No current ambient scope");
 
             efCoreScope.ExecuteWithContextAsync<Task>(database =>
@@ -160,7 +160,7 @@ private void ObtainReadLock()
         // lock occurs for entire database as opposed to row/table.
         private void ObtainWriteLock()
         {
-            IEfCoreScope<T>? efCoreScope = _parent._efCoreScopeAccessor.Value.AmbientScope
+            IEFCoreScope<T>? efCoreScope = _parent._efCoreScopeAccessor.Value.AmbientScope
                 ?? throw new PanicException("No ambient scope");
 
             efCoreScope.ExecuteWithContextAsync<Task>(async database =>
diff --git a/src/Umbraco.Cms.Persistence.SqlServer/Services/SqlServerSyntaxProvider.cs b/src/Umbraco.Cms.Persistence.SqlServer/Services/SqlServerSyntaxProvider.cs
index bea25ce08b1b..fdfe637f95de 100644
--- a/src/Umbraco.Cms.Persistence.SqlServer/Services/SqlServerSyntaxProvider.cs
+++ b/src/Umbraco.Cms.Persistence.SqlServer/Services/SqlServerSyntaxProvider.cs
@@ -466,6 +466,17 @@ public SqlInspectionUtilities()
 
     #endregion
 
+    /// <inheritdoc />
+    public override string CreateTempTable(string tableName, string columnDefinitionSql)
+        => $"CREATE TABLE #{tableName} ({columnDefinitionSql})";
+
+    /// <inheritdoc />
+    public override string TempTableName(string baseName) => $"#{baseName}";
+
+    /// <inheritdoc />
+    public override string DropTempTable(string tableName)
+        => $"DROP TABLE IF EXISTS #{tableName}";
+
     private sealed class SqlPrimaryKey
     {
         public string Name { get; set; } = null!;
diff --git a/src/Umbraco.Cms.Persistence.Sqlite/Services/SqliteSyntaxProvider.cs b/src/Umbraco.Cms.Persistence.Sqlite/Services/SqliteSyntaxProvider.cs
index a206ee6dac2c..535afb96a21a 100644
--- a/src/Umbraco.Cms.Persistence.Sqlite/Services/SqliteSyntaxProvider.cs
+++ b/src/Umbraco.Cms.Persistence.Sqlite/Services/SqliteSyntaxProvider.cs
@@ -507,6 +507,10 @@ private sealed class IndexMeta
         public bool IsUnique { get; set; }
     }
 
+    /// <inheritdoc />
+    public override string CreateTempTable(string tableName, string columnDefinitionSql)
+        => $"CREATE TEMP TABLE {tableName} ({columnDefinitionSql})";
+
     /// <inheritdoc />
     public override string Length => "length";
 
diff --git a/src/Umbraco.Cms.StaticAssets/umbraco/UmbracoBackOffice/Index.cshtml b/src/Umbraco.Cms.StaticAssets/umbraco/UmbracoBackOffice/Index.cshtml
index 671f578060c0..a665aa4cf616 100644
--- a/src/Umbraco.Cms.StaticAssets/umbraco/UmbracoBackOffice/Index.cshtml
+++ b/src/Umbraco.Cms.StaticAssets/umbraco/UmbracoBackOffice/Index.cshtml
@@ -34,7 +34,7 @@
     <title>Umbraco</title>
 
     <link rel="stylesheet" href="@backOfficeAssetsPath/css/umb-css.css" />
-    <link rel="stylesheet" href="@backOfficeAssetsPath/css/uui-css.css" />
+    <link rel="stylesheet" href="@backOfficeAssetsPath/css/light.css" />
     @await Html.BackOfficeImportMapScriptAsync(JsonSerializer, BackOfficePathGenerator, PackageManifestService, CspNonceService)
     <script type="module" src="@backOfficeAssetsPath/apps/app/app.element.js" asp-csp-nonce></script>
 </head>
diff --git a/src/Umbraco.Cms.StaticAssets/umbraco/UmbracoLogin/Index.cshtml b/src/Umbraco.Cms.StaticAssets/umbraco/UmbracoLogin/Index.cshtml
index 7b08860108cf..995e13dfa292 100644
--- a/src/Umbraco.Cms.StaticAssets/umbraco/UmbracoLogin/Index.cshtml
+++ b/src/Umbraco.Cms.StaticAssets/umbraco/UmbracoLogin/Index.cshtml
@@ -46,7 +46,7 @@
     <meta name="pinterest" content="nopin"/>
     <title>Umbraco</title>
 
-    <link rel="stylesheet" href="~/umbraco/backoffice/css/uui-css.css" asp-append-version="true" />
+    <link rel="stylesheet" href="~/umbraco/backoffice/css/light.css" asp-append-version="true" />
     <style>
       body {
         margin: 0;
diff --git a/src/Umbraco.Core/Cache/DistributedCacheExtensions.cs b/src/Umbraco.Core/Cache/DistributedCacheExtensions.cs
index 8d2b5046a8c5..ec277ddd1fa3 100644
--- a/src/Umbraco.Core/Cache/DistributedCacheExtensions.cs
+++ b/src/Umbraco.Core/Cache/DistributedCacheExtensions.cs
@@ -374,13 +374,25 @@ public static void RefreshMediaCache(this DistributedCache dc, IEnumerable<TreeC
 
     #region ElementCacheRefresher
 
+    /// <summary>
+    ///     Refreshes all elements in the distributed cache.
+    /// </summary>
+    /// <param name="dc">The distributed cache.</param>
     public static void RefreshAllElementCache(this DistributedCache dc)
         // note: refresh all element cache does refresh content types too
         => dc.RefreshByPayload(ElementCacheRefresher.UniqueId, new ElementCacheRefresher.JsonPayload(0, Guid.Empty, TreeChangeTypes.RefreshAll).Yield());
 
-
+    /// <summary>
+    ///     Refreshes the element cache for the specified element changes.
+    /// </summary>
+    /// <param name="dc">The distributed cache.</param>
+    /// <param name="changes">The element changes to refresh.</param>
     public static void RefreshElementCache(this DistributedCache dc, IEnumerable<TreeChange<IElement>> changes)
-        => dc.RefreshByPayload(ElementCacheRefresher.UniqueId, changes.DistinctBy(x => (x.Item.Id, x.Item.Key, x.ChangeTypes)).Select(x => new ElementCacheRefresher.JsonPayload(x.Item.Id, x.Item.Key, x.ChangeTypes)));
+        => dc.RefreshByPayload(ElementCacheRefresher.UniqueId, changes.DistinctBy(x => (x.Item.Id, x.Item.Key, x.ChangeTypes)).Select(x => new ElementCacheRefresher.JsonPayload(x.Item.Id, x.Item.Key, x.ChangeTypes)
+        {
+            PublishedCultures = x.PublishedCultures?.ToArray(),
+            UnpublishedCultures = x.UnpublishedCultures?.ToArray(),
+        }));
 
     #endregion
 
diff --git a/src/Umbraco.Core/Cache/Refreshers/Implement/ContentCacheRefresher.cs b/src/Umbraco.Core/Cache/Refreshers/Implement/ContentCacheRefresher.cs
index 72a23ff13393..4e91f96a0bf8 100644
--- a/src/Umbraco.Core/Cache/Refreshers/Implement/ContentCacheRefresher.cs
+++ b/src/Umbraco.Core/Cache/Refreshers/Implement/ContentCacheRefresher.cs
@@ -223,27 +223,30 @@ public override void Refresh(JsonPayload[] payloads)
         base.Refresh(payloads);
     }
 
-    private static bool ShouldClearPartialViewCache(JsonPayload[] payloads)
-    {
-        return payloads.Any(x =>
+    internal static bool ShouldClearPartialViewCache(IEnumerable<(TreeChangeTypes ChangeTypes, string[]? PublishedCultures, string[]? UnpublishedCultures)> changes)
+        => changes.Any(change =>
         {
-            // Check for relelvant change type
-            var isRelevantChangeType = x.ChangeTypes.HasType(TreeChangeTypes.RefreshAll) ||
-                x.ChangeTypes.HasType(TreeChangeTypes.Remove) ||
-                x.ChangeTypes.HasType(TreeChangeTypes.RefreshNode) ||
-                x.ChangeTypes.HasType(TreeChangeTypes.RefreshBranch);
+            // Check for relevant change type
+            var isRelevantChangeType = change.ChangeTypes.HasType(TreeChangeTypes.RefreshAll) ||
+                                       change.ChangeTypes.HasType(TreeChangeTypes.Remove) ||
+                                       change.ChangeTypes.HasType(TreeChangeTypes.RefreshNode) ||
+                                       change.ChangeTypes.HasType(TreeChangeTypes.RefreshBranch);
 
             // Check for published/unpublished changes
-            var hasChanges = x.PublishedCultures?.Length > 0 ||
-                   x.UnpublishedCultures?.Length > 0;
+            var hasChanges = change.PublishedCultures?.Length > 0 ||
+                             change.UnpublishedCultures?.Length > 0;
 
-            // There's no other way to detect trashed content as the change type is only Remove when deleted permanently
-            var isTrashed = x.ChangeTypes.HasType(TreeChangeTypes.RefreshBranch) && x.PublishedCultures is null && x.UnpublishedCultures is null;
+            // There's no other way to detect trashed state as the change type is only Remove when deleted permanently
+            var isTrashed = change.ChangeTypes.HasType(TreeChangeTypes.RefreshBranch) && change.PublishedCultures is null && change.UnpublishedCultures is null;
 
-            // Skip blueprints and only clear the partial cache for removals or refreshes with changes
-            return x.Blueprint == false && (isTrashed || (isRelevantChangeType && hasChanges));
+            // Only clear the partial cache for removals or refreshes with changes
+            return isTrashed || (isRelevantChangeType && hasChanges);
         });
-    }
+
+    private static bool ShouldClearPartialViewCache(JsonPayload[] payloads)
+        => ShouldClearPartialViewCache(payloads
+            .Where(payload => payload.Blueprint is false)
+            .Select(payload => (payload.ChangeTypes, payload.PublishedCultures, payload.UnpublishedCultures)));
 
     private void HandleMemoryCache(JsonPayload payload)
     {
@@ -501,11 +504,10 @@ private void HandleDomainCache(HashSet<int> idsRemoved)
             return;
         }
 
-#pragma warning disable CS0618 // Type or member is obsolete
-        var assignedDomains = _domainService.GetAll(true)
+        // TODO: Make async when EFCore migration is completed.
+        var assignedDomains = _domainService.GetAllAsync(true).GetAwaiter().GetResult()
             .Where(x => x.RootContentId.HasValue && idsRemoved.Contains(x.RootContentId.Value))
             .ToList();
-#pragma warning restore CS0618 // Type or member is obsolete
         if (assignedDomains.Count <= 0)
         {
             return;
diff --git a/src/Umbraco.Core/Cache/Refreshers/Implement/ContentTypeCacheRefresher.cs b/src/Umbraco.Core/Cache/Refreshers/Implement/ContentTypeCacheRefresher.cs
index 08f90cf18fdd..405928b61685 100644
--- a/src/Umbraco.Core/Cache/Refreshers/Implement/ContentTypeCacheRefresher.cs
+++ b/src/Umbraco.Core/Cache/Refreshers/Implement/ContentTypeCacheRefresher.cs
@@ -181,21 +181,25 @@ public override void Refresh(JsonPayload[] payloads)
             var structuralDocumentTypeIds = payloads
                 .Where(x => x.ItemType == nameof(IContentType) && x.ChangeTypes.IsStructuralChange())
                 .Select(x => x.Id)
+                .Distinct()
                 .ToArray();
 
             var nonStructuralDocumentTypeIds = payloads
                 .Where(x => x.ItemType == nameof(IContentType) && x.ChangeTypes.IsNonStructuralChange())
                 .Select(x => x.Id)
+                .Distinct()
                 .ToArray();
 
             var structuralMediaTypeIds = payloads
                 .Where(x => x.ItemType == nameof(IMediaType) && x.ChangeTypes.IsStructuralChange())
                 .Select(x => x.Id)
+                .Distinct()
                 .ToArray();
 
             var nonStructuralMediaTypeIds = payloads
                 .Where(x => x.ItemType == nameof(IMediaType) && x.ChangeTypes.IsNonStructuralChange())
                 .Select(x => x.Id)
+                .Distinct()
                 .ToArray();
 
             // Full memory cache rebuild only for structural changes
diff --git a/src/Umbraco.Core/Cache/Refreshers/Implement/ElementCacheRefresher.cs b/src/Umbraco.Core/Cache/Refreshers/Implement/ElementCacheRefresher.cs
index 169073f650e0..c4a06ece4f12 100644
--- a/src/Umbraco.Core/Cache/Refreshers/Implement/ElementCacheRefresher.cs
+++ b/src/Umbraco.Core/Cache/Refreshers/Implement/ElementCacheRefresher.cs
@@ -10,12 +10,25 @@
 
 namespace Umbraco.Cms.Core.Cache;
 
+/// <summary>
+/// Provides cache refresh functionality for element items, ensuring that element-related caches are updated or
+/// invalidated in response to element changes.
+/// </summary>
+/// <remarks>
+/// The ElementCacheRefresher coordinates cache invalidation for elements, including memory caches and
+/// isolated caches. It responds to element change notifications and ensures that all relevant caches reflect
+/// the current state of published and unpublished elements. This refresher is used internally to maintain
+/// cache consistency after element operations such as publish, unpublish, or delete.
+/// </remarks>
 public sealed class ElementCacheRefresher : PayloadCacheRefresherBase<ElementCacheRefresherNotification, ElementCacheRefresher.JsonPayload>
 {
     private readonly IIdKeyMap _idKeyMap;
     private readonly IElementCacheService _elementCacheService;
     private readonly ICacheManager _cacheManager;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ElementCacheRefresher"/> class.
+    /// </summary>
     public ElementCacheRefresher(
         AppCaches appCaches,
         IJsonSerializer serializer,
@@ -35,6 +48,10 @@ public ElementCacheRefresher(
 
     #region Json
 
+    /// <summary>
+    /// Represents a JSON-serializable payload containing information about an element change event, including
+    /// identifiers, change types, and culture-specific publishing details.
+    /// </summary>
     public class JsonPayload
     {
         public JsonPayload(int id, Guid key, TreeChangeTypes changeTypes)
@@ -44,23 +61,45 @@ public JsonPayload(int id, Guid key, TreeChangeTypes changeTypes)
             ChangeTypes = changeTypes;
         }
 
+        /// <summary>
+        /// Gets the unique integer identifier for the entity.
+        /// </summary>
         public int Id { get; }
 
+        /// <summary>
+        /// Gets the unique GUID key associated with the entity.
+        /// </summary>
         public Guid Key { get; }
 
+        /// <summary>
+        /// Gets the types of changes that have occurred in the tree.
+        /// </summary>
         public TreeChangeTypes ChangeTypes { get; }
 
-        // TODO ELEMENTS: should we support (un)published cultures in this payload? see ContentCacheRefresher.JsonPayload
+        /// <summary>
+        /// Gets the collection of culture codes in which the element is published.
+        /// </summary>
+        public string[]? PublishedCultures { get; init; }
+
+        /// <summary>
+        /// Gets the collection of culture codes for which the element has been unpublished.
+        /// </summary>
+        public string[]? UnpublishedCultures { get; init; }
     }
 
     #endregion
 
     #region Define
 
+    /// <summary>
+    /// Represents a unique identifier for the cache refresher.
+    /// </summary>
     public static readonly Guid UniqueId = Guid.Parse("EE5BB23A-A656-4F7E-A234-16F21AAABFD1");
 
+    /// <inheritdoc/>
     public override Guid RefresherUniqueId => UniqueId;
 
+    /// <inheritdoc/>
     public override string Name => "Element Cache Refresher";
 
     #endregion
@@ -93,17 +132,25 @@ public override void Refresh(JsonPayload[] payloads)
             // TODO ELEMENTS: if we need published status caching for elements (e.g. for seeding purposes), make sure
             //                it is kept in sync here (see ContentCacheRefresher)
 
-            if (payload.ChangeTypes == TreeChangeTypes.Remove)
+            if (payload.ChangeTypes.HasType(TreeChangeTypes.Remove))
             {
                 _idKeyMap.ClearCache(payload.Id);
             }
         }
 
-        AppCaches.ClearPartialViewCache();
+        if (ShouldClearPartialViewCache(payloads))
+        {
+            AppCaches.ClearPartialViewCache();
+        }
 
         base.Refresh(payloads);
     }
 
+    private static bool ShouldClearPartialViewCache(JsonPayload[] payloads)
+        // Reuse the "should clear partial view cache" logic from the content cache refresher.
+        => ContentCacheRefresher.ShouldClearPartialViewCache(payloads
+            .Select(payload => (payload.ChangeTypes, payload.PublishedCultures, payload.UnpublishedCultures)));
+
     private void HandleMemoryCache(JsonPayload payload)
     {
         if (payload.ChangeTypes.HasType(TreeChangeTypes.RefreshAll))
@@ -122,14 +169,18 @@ private void HandleMemoryCache(JsonPayload payload)
         }
     }
 
-    // these events should never trigger
-    // everything should be JSON
+    // These events should never trigger. Everything should be PAYLOAD/JSON.
+
+    /// <inheritdoc/>
     public override void RefreshAll() => throw new NotSupportedException();
 
+    /// <inheritdoc/>
     public override void Refresh(int id) => throw new NotSupportedException();
 
+    /// <inheritdoc/>
     public override void Refresh(Guid id) => throw new NotSupportedException();
 
+    /// <inheritdoc/>
     public override void Remove(int id) => throw new NotSupportedException();
 
     #endregion
diff --git a/src/Umbraco.Core/Configuration/IConfigManipulator.cs b/src/Umbraco.Core/Configuration/IConfigManipulator.cs
index 43ccdf199160..99c7e1034a18 100644
--- a/src/Umbraco.Core/Configuration/IConfigManipulator.cs
+++ b/src/Umbraco.Core/Configuration/IConfigManipulator.cs
@@ -55,7 +55,5 @@ public interface IConfigManipulator
     /// </remarks>
     /// </summary>
     /// <param name="base64Key">The base64-encoded key to save.</param>
-    // TODO (V18): Remove the default implementation.
-    Task SetImagingHmacSecretKeyAsync(string base64Key)
-        => Task.CompletedTask;
+    Task SetImagingHmacSecretKeyAsync(string base64Key);
 }
diff --git a/src/Umbraco.Core/Configuration/Models/ApplicationUrlDetection.cs b/src/Umbraco.Core/Configuration/Models/ApplicationUrlDetection.cs
new file mode 100644
index 000000000000..3649cd6c9e86
--- /dev/null
+++ b/src/Umbraco.Core/Configuration/Models/ApplicationUrlDetection.cs
@@ -0,0 +1,27 @@
+namespace Umbraco.Cms.Core.Configuration.Models;
+
+/// <summary>
+///     Specifies how the application main URL is detected from incoming HTTP requests.
+/// </summary>
+public enum ApplicationUrlDetection
+{
+    /// <summary>
+    ///     No auto-detection. The application URL must be explicitly configured
+    ///     via <see cref="WebRoutingSettings.UmbracoApplicationUrl" />.
+    ///     Operations that require a URL (invitations, password resets) will fail
+    ///     if no explicit URL is configured.
+    /// </summary>
+    None,
+
+    /// <summary>
+    ///     The URL is set from the first HTTP request and then locked.
+    ///     Subsequent requests with different host headers are ignored.
+    /// </summary>
+    FirstRequest,
+
+    /// <summary>
+    ///     The URL is updated from every new incoming HTTP request (legacy behavior).
+    ///     This is vulnerable to host header poisoning.
+    /// </summary>
+    EveryRequest,
+}
diff --git a/src/Umbraco.Core/Configuration/Models/ContentSettings.cs b/src/Umbraco.Core/Configuration/Models/ContentSettings.cs
index a13b7135ccb0..270b7f59e5f9 100644
--- a/src/Umbraco.Core/Configuration/Models/ContentSettings.cs
+++ b/src/Umbraco.Core/Configuration/Models/ContentSettings.cs
@@ -88,11 +88,10 @@ public class ContentSettings
     /// </summary>
     internal const bool StaticShowUnroutableContentWarnings = true;
 
-    // TODO (V18): Consider enabling this by default and documenting as a behavioural breaking change.
     /// <summary>
     ///     The default value for enabling media recycle bin protection.
     /// </summary>
-    private const bool StaticEnableMediaRecycleBinProtection = false;
+    private const bool StaticEnableMediaRecycleBinProtection = true;
 
     /// <summary>
     ///     Gets or sets a value for the content notification settings.
diff --git a/src/Umbraco.Core/Configuration/Models/ContentVersionCleanupPolicySettings.cs b/src/Umbraco.Core/Configuration/Models/ContentVersionCleanupPolicySettings.cs
index ed721382a963..39023ad99884 100644
--- a/src/Umbraco.Core/Configuration/Models/ContentVersionCleanupPolicySettings.cs
+++ b/src/Umbraco.Core/Configuration/Models/ContentVersionCleanupPolicySettings.cs
@@ -10,6 +10,7 @@ public class ContentVersionCleanupPolicySettings
     private const bool StaticEnableCleanup = false;
     private const int StaticKeepAllVersionsNewerThanDays = 7;
     private const int StaticKeepLatestVersionPerDayForDays = 90;
+    private const int StaticMaxVersionsToDeletePerRun = 50_000;
 
     /// <summary>
     ///     Gets or sets a value indicating whether or not the cleanup job should be executed.
@@ -28,4 +29,12 @@ public class ContentVersionCleanupPolicySettings
     /// </summary>
     [DefaultValue(StaticKeepLatestVersionPerDayForDays)]
     public int KeepLatestVersionPerDayForDays { get; set; } = StaticKeepLatestVersionPerDayForDays;
+
+    /// <summary>
+    ///     Gets or sets the maximum number of content versions to process per cleanup run.
+    ///     When more versions are eligible, they will be processed in subsequent runs.
+    ///     A value of 0 means no limit (process all eligible versions).
+    /// </summary>
+    [DefaultValue(StaticMaxVersionsToDeletePerRun)]
+    public int MaxVersionsToDeletePerRun { get; set; } = StaticMaxVersionsToDeletePerRun;
 }
diff --git a/src/Umbraco.Core/Configuration/Models/SecuritySettings.cs b/src/Umbraco.Core/Configuration/Models/SecuritySettings.cs
index b1469534b388..3c39ae412663 100644
--- a/src/Umbraco.Core/Configuration/Models/SecuritySettings.cs
+++ b/src/Umbraco.Core/Configuration/Models/SecuritySettings.cs
@@ -279,15 +279,6 @@ public class SecuritySettings
     /// <remarks>
     ///     This property exists to enable IntelliSense/autocomplete in appsettings.json
     ///     for the <c>Umbraco:CMS:Security:UserPassword</c> configuration section.
-    ///     <para>
-    ///         Do not use this property to read password configuration at runtime.
-    ///         Inject <see cref="IOptions{UserPasswordConfigurationSettings}"/> directly instead,
-    ///         as that is the canonical registration used by all consumers.
-    ///     </para>
-    ///     <para>
-    ///         TODO (V18): Remove the standalone <see cref="UserPasswordConfigurationSettings"/>
-    ///         registration and consolidate all consumers to use this property.
-    ///     </para>
     /// </remarks>
     public UserPasswordConfigurationSettings UserPassword { get; set; } = new();
 
@@ -297,14 +288,6 @@ public class SecuritySettings
     /// <remarks>
     ///     This property exists to enable IntelliSense/autocomplete in appsettings.json
     ///     for the <c>Umbraco:CMS:Security:MemberPassword</c> configuration section.
-    ///     <para>
-    ///         Do not use this property to read password configuration at runtime.
-    ///         Inject <see cref="IOptions{MemberPasswordConfigurationSettings}"/> directly instead,
-    ///         as that is the canonical registration used by all consumers.
-    ///     </para>
-    ///     <para>
-    ///         TODO (V18): Remove the standalone <see cref="MemberPasswordConfigurationSettings"/>
-    ///         registration and consolidate all consumers to use this property.
-    ///     </para>
+    /// </remarks>
     public MemberPasswordConfigurationSettings MemberPassword { get; set; } = new();
 }
diff --git a/src/Umbraco.Core/Configuration/Models/Validation/HostingSettingsValidator.cs b/src/Umbraco.Core/Configuration/Models/Validation/HostingSettingsValidator.cs
new file mode 100644
index 000000000000..aa5987e2a6cf
--- /dev/null
+++ b/src/Umbraco.Core/Configuration/Models/Validation/HostingSettingsValidator.cs
@@ -0,0 +1,29 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.Factories;
+
+namespace Umbraco.Cms.Core.Configuration.Models.Validation;
+
+/// <summary>
+///     Validator for configuration represented as <see cref="HostingSettings" />.
+/// </summary>
+public class HostingSettingsValidator
+    : ConfigurationValidatorBase, IValidateOptions<HostingSettings>
+{
+    /// <inheritdoc />
+    public ValidateOptionsResult Validate(string? name, HostingSettings options)
+    {
+        var identifier = MachineInfoFactory.BuildMachineIdentifier(Environment.MachineName, options.SiteName);
+
+        if (identifier.Length > MachineInfoFactory.MaxMachineIdentifierLength)
+        {
+            return ValidateOptionsResult.Fail(
+                $"The combined machine identifier '{identifier}' ({identifier.Length} characters) exceeds the maximum allowed length of {MachineInfoFactory.MaxMachineIdentifierLength} characters. " +
+                $"Please shorten the value of '{Constants.Configuration.ConfigHostingPrefix}{nameof(HostingSettings.SiteName)}'.");
+        }
+
+        return ValidateOptionsResult.Success;
+    }
+}
diff --git a/src/Umbraco.Core/Configuration/Models/WebRoutingSettings.cs b/src/Umbraco.Core/Configuration/Models/WebRoutingSettings.cs
index 656a27fe9b86..72179f43b05e 100644
--- a/src/Umbraco.Core/Configuration/Models/WebRoutingSettings.cs
+++ b/src/Umbraco.Core/Configuration/Models/WebRoutingSettings.cs
@@ -62,6 +62,11 @@ public class WebRoutingSettings
     /// </summary>
     internal const bool StaticUseStrictDomainMatching = false;
 
+    /// <summary>
+    ///     The default value for application URL detection mode.
+    /// </summary>
+    internal const ApplicationUrlDetection StaticApplicationUrlDetection = ApplicationUrlDetection.None;
+
     /// <summary>
     ///     Gets or sets a value indicating whether to check if any routed endpoints match a front-end request before
     ///     the Umbraco dynamic router tries to map the request to an Umbraco content item.
@@ -123,11 +128,18 @@ public class WebRoutingSettings
     /// </summary>
     public string UmbracoApplicationUrl { get; set; } = null!;
 
+    /// <summary>
+    ///     Gets or sets a value controlling how the application main URL is auto-detected
+    ///     from incoming HTTP requests (<see cref="ApplicationUrlDetection" />).
+    /// </summary>
+    [DefaultValue(StaticApplicationUrlDetection)]
+    public ApplicationUrlDetection ApplicationUrlDetection { get; set; } = StaticApplicationUrlDetection;
+
     /// <summary>
     ///     Gets or sets a value indicating whether strict domain matching is used when finding content to match the request.
     /// </summary>
     /// <remarks>
-    ///     <para>This setting is used within Umbraco's routing process based on content finders, specifically <see cref="Routing.ContentFinderByUrlNew" />.</para>
+    ///     <para>This setting is used within Umbraco's routing process based on content finders, specifically <see cref="Routing.ContentFinderByUrl" />.</para>
     ///     <para>If set to the default value of <see langword="false"/>, requests that don't match a configured domain will be routed to the first root node.</para>
     ///     <para>If set to <see langword="true"/>, requests that don't match a configured domain will not be routed.</para>
     /// </remarks>
diff --git a/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Collections.cs b/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Collections.cs
index 1825f0ab4754..023363769091 100644
--- a/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Collections.cs
+++ b/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Collections.cs
@@ -40,7 +40,7 @@ internal static void AddAllCoreCollectionBuilders(this IUmbracoBuilder builder)
         // devs can then modify this list on application startup
         builder.ContentFinders()
             .Append<ContentFinderByPageIdQuery>()
-            .Append<ContentFinderByUrlNew>()
+            .Append<ContentFinderByUrl>()
             .Append<ContentFinderByKeyPath>()
             .Append<ContentFinderByUrlAlias>()
             .Append<ContentFinderByRedirectUrl>();
@@ -49,7 +49,7 @@ internal static void AddAllCoreCollectionBuilders(this IUmbracoBuilder builder)
         builder.HealthCheckNotificationMethods().Add(() => builder.TypeLoader.GetTypes<IHealthCheckNotificationMethod>());
         builder.UrlProviders()
             .Append<AliasUrlProvider>()
-            .Append<NewDefaultUrlProvider>();
+            .Append<DefaultUrlProvider>();
         builder.MediaUrlProviders()
             .Append<DefaultMediaUrlProvider>();
 
diff --git a/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Configuration.cs b/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Configuration.cs
index fb4d9b5217a5..8896e3a25eb9 100644
--- a/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Configuration.cs
+++ b/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.Configuration.cs
@@ -52,6 +52,7 @@ public static IUmbracoBuilder AddConfiguration(this IUmbracoBuilder builder)
         builder.Services.AddSingleton<IValidateOptions<DeliveryApiSettings>, DeliveryApiSettingsValidator>();
         builder.Services.AddSingleton<IValidateOptions<GlobalSettings>, GlobalSettingsValidator>();
         builder.Services.AddSingleton<IValidateOptions<HealthChecksSettings>, HealthChecksSettingsValidator>();
+        builder.Services.AddSingleton<IValidateOptions<HostingSettings>, HostingSettingsValidator>();
         builder.Services.AddSingleton<IValidateOptions<LoggingSettings>, LoggingSettingsValidator>();
         builder.Services.AddSingleton<IValidateOptions<RequestHandlerSettings>, RequestHandlerSettingsValidator>();
         builder.Services.AddSingleton<IValidateOptions<UnattendedSettings>, UnattendedSettingsValidator>();
diff --git a/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs b/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs
index f7edb94f7725..307ab5e2ada8 100644
--- a/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs
+++ b/src/Umbraco.Core/DependencyInjection/UmbracoBuilder.cs
@@ -338,11 +338,11 @@ private void AddCoreServices()
             Services.AddUnique<IContentTypeEditingService, ContentTypeEditingService>();
             Services.AddUnique<IMediaTypeEditingService, MediaTypeEditingService>();
             Services.AddUnique<IFileService, FileService>();
-            Services.AddUnique<ITemplateService>(sp => ActivatorUtilities.CreateInstance<TemplateService>(sp));
+            Services.AddUnique<ITemplateService, TemplateService>();
             Services.AddUnique<IScriptService, ScriptService>();
             Services.AddUnique<IStylesheetService, StylesheetService>();
             Services.AddUnique<IStylesheetFolderService, StylesheetFolderService>();
-            Services.AddUnique<IPartialViewService>(sp => ActivatorUtilities.CreateInstance<PartialViewService>(sp));
+            Services.AddUnique<IPartialViewService, PartialViewService>();
             Services.AddUnique<IScriptFolderService, ScriptFolderService>();
             Services.AddUnique<IPartialViewFolderService, PartialViewFolderService>();
             Services.AddUnique<ITemporaryFileService, TemporaryFileService>();
diff --git a/src/Umbraco.Core/DynamicRoot/Origin/SiteDynamicRootOriginFinder.cs b/src/Umbraco.Core/DynamicRoot/Origin/SiteDynamicRootOriginFinder.cs
index 7579d9bcc653..10eb0819e891 100644
--- a/src/Umbraco.Core/DynamicRoot/Origin/SiteDynamicRootOriginFinder.cs
+++ b/src/Umbraco.Core/DynamicRoot/Origin/SiteDynamicRootOriginFinder.cs
@@ -45,7 +45,8 @@ public SiteDynamicRootOriginFinder(IEntityService entityService, IDomainService
         for (int i = contentIdStrings.Length - 1; i >= 0; i--)
         {
             var contentId = int.Parse(contentIdStrings[i], NumberStyles.Integer, CultureInfo.InvariantCulture);
-            IEnumerable<IDomain> domains = _domainService.GetAssignedDomains(contentId, true);
+            // TODO: Remove int-based overload when EFCore migration is completed.
+            IEnumerable<IDomain> domains = _domainService.GetAssignedDomainsAsync(contentId, true).GetAwaiter().GetResult();
             if (!domains.Any())
             {
                 continue;
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/bs.xml b/src/Umbraco.Core/EmbeddedResources/Lang/bs.xml
index 0637f4842630..1261c0b8661b 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/bs.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/bs.xml
@@ -448,10 +448,6 @@
     <key alias="scheduledHealthCheckEmailBody"><![CDATA[<html><body><p>Rezultati zakazanih Umbraco provjera zdravlja koji se pokreću na %0% na %1% su sljedeći:</p>%2%</body></html>]]></key>
     <key alias="scheduledHealthCheckEmailSubject">Status provjere zdravlja Umbraco: %0%</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Sadržaj u otpadu s ID-om: {0} povezan je s originalnim nadređenim sadržajem s ID-om: {1}</key>
-    <key alias="mediaTrashed">Medij u otpadu s ID-om: {0} povezan je s originalnim nadređenim medijem s ID-om: {1}</key>
-  </area>
   <area alias="permissions">
     <key alias="FolderCreation">Kreiranje foldera</key>
     <key alias="FileWritingForPackages">Pisanje datoteka za pakete</key>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/cs.xml b/src/Umbraco.Core/EmbeddedResources/Lang/cs.xml
index 816f3a11f0ab..6770fbecac50 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/cs.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/cs.xml
@@ -354,8 +354,4 @@
     <key alias="scheduledHealthCheckEmailBody"><![CDATA[<html><body><p>Výsledky plánovaných kontrol Umbraco Health Checks provedených na %0% v %1% jsou následující:</p>%2%</body></html>]]></key>
     <key alias="scheduledHealthCheckEmailSubject">Stav Umbraco Health Check: %0%</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Obsah s ID: {0} v koši souvisí s původním nadřazeným obsahem s ID: {1}</key>
-    <key alias="mediaTrashed">Média s ID: {0} v koši souvisí s původním nadřazeným médiem s ID: {1}</key>
-  </area>
 </language>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/cy.xml b/src/Umbraco.Core/EmbeddedResources/Lang/cy.xml
index a448ba1740e1..dfc4e4a283fe 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/cy.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/cy.xml
@@ -459,10 +459,6 @@
     <key alias="smtpMailSettingsHostNotConfigured">Nid oedd modd dod o hyd i'r ffurfweddiad 'Umbraco:CMS:Global:Smtp:Host'.</key>
     <key alias="smtpMailSettingsConnectionFail">Methwyd cyrraedd y gweinydd SMTP a ffurfweddwyd gyda gwesteiwr '%0%' a phorth '%1%'. Gwiriwch i sicrhau bod y gosodiadau SMTP yn y ffurfweddiad 'Umbraco:CMS:Global:Smtp' yn gywir.</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Wedi chwalu cynnwys gyda Id: {0} yn berthnasol i gynnwys rhiant gwreiddiol gyda Id: {1}</key>
-    <key alias="mediaTrashed">Wedi chwalu cyfrwng gyda Id: {0} yn berthnasol i gyfrwng rhiant gwreiddiol gyda Id: {1}</key>
-  </area>
   <area alias="permissions">
     <key alias="FolderCreation">Creu ffolder</key>
     <key alias="FileWritingForPackages">Ysgrifennu ffeiliau ar gyfer pecynnau</key>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/da.xml b/src/Umbraco.Core/EmbeddedResources/Lang/da.xml
index f2cd356494c5..fe9decb97747 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/da.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/da.xml
@@ -208,10 +208,6 @@
     <key alias="multipleNotOneOfOptions">Værdierne '%0%' er ikke tilstede i de tilgængelige valgmuligheder.</key>
     <key alias="invalidColor">"Den valgte farve '%0%' er ikke en af de tilgængelige valgmuligheder.</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Slettet indhold med Id: {0} Relateret til original "parent" med id: {1}</key>
-    <key alias="mediaTrashed">Slettet medie med Id: {0} relateret til original "parent" / mappe med id: {1}</key>
-  </area>
   <area alias="permissions">
     <key alias="FolderCreation">Mappeoprettelse</key>
     <key alias="FileWritingForPackages">Filskrivning for pakker</key>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/de.xml b/src/Umbraco.Core/EmbeddedResources/Lang/de.xml
index 467261f3112c..fb521b03fed8 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/de.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/de.xml
@@ -393,10 +393,6 @@
     ]]></key>
     <key alias="scheduledHealthCheckEmailSubject">Status der Umbraco Systemzustand: %0%</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Inhalt mit Id = {0} des Oberknotens mit Id = {1} wurde verworfen</key>
-    <key alias="mediaTrashed">Medienelement mit Id = {0} des Oberknotens mit Id = {1} wurde verworfen</key>
-  </area>
   <area alias="permissions">
     <key alias="FolderCreation">Ornder erstellen</key>
     <key alias="FileWritingForPackages">Dateien durch Packages erstellen lassen</key>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/de_ch.xml b/src/Umbraco.Core/EmbeddedResources/Lang/de_ch.xml
index 1b3b5dad4500..b42fa51c2905 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/de_ch.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/de_ch.xml
@@ -2335,16 +2335,7 @@
 	<area alias="textbox">
 		<key alias="characters_left">Buchstaben verbleiben</key>
 	</area>
-	<area alias="recycleBin">
-		<key alias="contentTrashed">Inhalt mit Id = {0} des Oberknotens mit Id = {1} wurde verworfen</key>
-		<key alias="mediaTrashed">Medienelement mit Id = {0} des Oberknotens mit Id = {1} wurde verworfen</key>
-		<key alias="itemCannotBeRestored">Dieses Element kann nicht automatisch wiederhergestellt werden</key>
-		<key alias="itemCannotBeRestoredHelpText">
-			Es gibt keine Position für das automatische Wiederherstellen dieses Elementes.
-			Sie können es manuell mit Hilfe der untenstehenden Baumstruktur verschieben.
-		</key>
-		<key alias="wasRestored">wurde wiederhergestellt unterhalb von</key>
-	</area>
+
 	<area alias="relationType">
 		<key alias="direction">Richtung</key>
 		<key alias="parentToChild">Ober- zu Unterknoten</key>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/en.xml b/src/Umbraco.Core/EmbeddedResources/Lang/en.xml
index c04b95fb9aac..e06ef827d572 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/en.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/en.xml
@@ -437,6 +437,7 @@
     <key alias="httpsCheckExpiredCertificate">Your website's SSL certificate has expired.</key>
     <key alias="httpsCheckExpiringCertificate">Your website's SSL certificate is expiring in %0% days.</key>
     <key alias="healthCheckInvalidUrl">Error pinging the URL %0% - '%1%'</key>
+    <key alias="httpsCheckNoApplicationUrl">The application URL is not available. Configure Umbraco:CMS:WebRouting:UmbracoApplicationUrl or change ApplicationUrlDetection to enable this check.</key>
     <key alias="httpsCheckIsCurrentSchemeHttps">You are currently %0% viewing the site using the HTTPS scheme.</key>
     <key alias="httpsCheckConfigurationRectifyNotPossible">The appSetting 'Umbraco:CMS:Global:UseHttps' is set to 'false' in
       your appSettings.json file. Once you access this site using the HTTPS scheme, that should be set to 'true'.
@@ -517,12 +518,6 @@
     <key alias="scheduledHealthCheckEmailBody"><![CDATA[<html><body><p>Results of the scheduled Umbraco Health Checks run on %0% at %1% are as follows:</p>%2%</body></html>]]></key>
     <key alias="scheduledHealthCheckEmailSubject">Umbraco Health Check Status: %0%</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Trashed content with Id: {0} related to original parent content with Id: {1}</key>
-    <key alias="mediaTrashed">Trashed media with Id: {0} related to original parent media item with Id: {1}</key>
-    <key alias="elementTrashed">Trashed element with Id: {0} related to original parent container with Id: {1}</key>
-    <key alias="elementContainerTrashed">Trashed element container with Id: {0} related to original parent container with Id: {1}</key>
-  </area>
   <area alias="permissions">
     <key alias="FolderCreation">Folder creation</key>
     <key alias="FileWritingForPackages">File writing for packages</key>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/en_us.xml b/src/Umbraco.Core/EmbeddedResources/Lang/en_us.xml
index fdb6b14f5929..882ce14af407 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/en_us.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/en_us.xml
@@ -426,6 +426,7 @@
     <key alias="httpsCheckExpiredCertificate">Your website's SSL certificate has expired.</key>
     <key alias="httpsCheckExpiringCertificate">Your website's SSL certificate is expiring in %0% days.</key>
     <key alias="healthCheckInvalidUrl">Error pinging the URL %0% - '%1%'</key>
+    <key alias="httpsCheckNoApplicationUrl">The application URL is not available. Configure Umbraco:CMS:WebRouting:UmbracoApplicationUrl or change ApplicationUrlDetection to enable this check.</key>
     <key alias="httpsCheckIsCurrentSchemeHttps">You are currently %0% viewing the site using the HTTPS scheme.</key>
     <key alias="httpsCheckConfigurationRectifyNotPossible">The appSetting 'Umbraco:CMS:Global:UseHttps' is set to 'false' in
       your appSettings.json file. Once you access this site using the HTTPS scheme, that should be set to 'true'.
@@ -507,10 +508,6 @@
       <![CDATA[<html><body><p>Results of the scheduled Umbraco Health Checks run on %0% at %1% are as follows:</p>%2%</body></html>]]></key>
     <key alias="scheduledHealthCheckEmailSubject">Umbraco Health Check Status: %0%</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Trashed content with Id: {0} related to original parent content with Id: {1}</key>
-    <key alias="mediaTrashed">Trashed media with Id: {0} related to original parent media item with Id: {1}</key>
-  </area>
   <area alias="permissions">
     <key alias="FolderCreation">Folder creation</key>
     <key alias="FileWritingForPackages">File writing for packages</key>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/fr.xml b/src/Umbraco.Core/EmbeddedResources/Lang/fr.xml
index 4602a868c097..776c4d52690a 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/fr.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/fr.xml
@@ -416,8 +416,4 @@
     <key alias="scheduledHealthCheckEmailBody"><![CDATA[<html><body><p>Les résultats de l'exécution du Umbraco Health Checks planifiée le %0% à %1% sont les suivants :</p>%2%</body></html>]]></key>
     <key alias="scheduledHealthCheckEmailSubject">Statut du Umbraco Health Check: %0%</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Suppression du contenu avec l'Id : {0} lié au contenu parent original avec l'Id : {1}</key>
-    <key alias="mediaTrashed">Suppression du media avec l'Id : {0} lié à l'élément media parent original avec l'Id : {1}</key>
-  </area>
 </language>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/fr_ch.xml b/src/Umbraco.Core/EmbeddedResources/Lang/fr_ch.xml
index 59619b1201f7..ae0a2f75b125 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/fr_ch.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/fr_ch.xml
@@ -2150,13 +2150,7 @@ Pour gérer votre site, ouvrez simplement le backoffice Umbraco et commencez à
 		<key alias="characters_left"><![CDATA[<strong>%0%</strong> caractères restant.]]></key>
 		<key alias="characters_exceed"><![CDATA[Maximum %0% caractères, <strong>%1%</strong> en trop.]]></key>
 	</area>
-	<area alias="recycleBin">
-		<key alias="contentTrashed">Suppression du contenu avec l'Id : {0} lié au contenu parent original avec l'Id : {1}</key>
-		<key alias="mediaTrashed">Suppression du media avec l'Id : {0} lié à l'élément media parent original avec l'Id : {1}</key>
-		<key alias="itemCannotBeRestored">Cet élément ne peut pas être restauré automatiquement</key>
-		<key alias="itemCannotBeRestoredHelpText">Il n'y a aucun endroit où cet élément peut être restauré automatiquement. Vous pouvez déplacer l'élément manuellement en utilisant l'arborescence ci-dessous.</key>
-		<key alias="wasRestored">a été restauré sous</key>
-	</area>
+
 	<area alias="relationType">
 		<key alias="direction">Direction</key>
 		<key alias="parentToChild">Parent vers enfant</key>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/hr.xml b/src/Umbraco.Core/EmbeddedResources/Lang/hr.xml
index 9ba18717a2b1..ed4e51a526f1 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/hr.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/hr.xml
@@ -446,10 +446,6 @@
     <key alias="scheduledHealthCheckEmailBody"><![CDATA[<html><body><p>Rezultati zakazanih Umbraco provjera zdravlja koji se pokreću na %0% na %1% su sljedeći:</p>%2%</body></html>]]></key>
     <key alias="scheduledHealthCheckEmailSubject">Status provjere zdravlja Umbraco: %0%</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Sadržaj u otpadu s ID-om: {0} povezan je s originalnim nadređenim sadržajem s ID-om: {1}</key>
-    <key alias="mediaTrashed">Medij u otpadu s ID-om: {0} povezan je s originalnim nadređenim medijem s ID-om: {1}</key>
-  </area>
   <area alias="permissions">
     <key alias="FolderCreation">Kreiranje mape</key>
     <key alias="FileWritingForPackages">Pisanje datoteka za pakete</key>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/it.xml b/src/Umbraco.Core/EmbeddedResources/Lang/it.xml
index f66ff3b95b98..8886ca531487 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/it.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/it.xml
@@ -449,9 +449,4 @@
     <key alias="scheduledHealthCheckEmailBody"><![CDATA[<html><body><p>I risultati dell'Health Check programmato di Umbraco del %0% alle %1% è il seguente:</p>%2%</body></html>]]></key>
     <key alias="scheduledHealthCheckEmailSubject">Stato dell'Health Check di Umbraco: %0%</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Contenuto cestinato con Id: {0} relativo al contenuto principale originale con Id: {1}
-    </key>
-    <key alias="mediaTrashed">Media cestinato con Id: {0} relativo al media principale originale con Id: {1}</key>
-  </area>
 </language>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/it_ch.xml b/src/Umbraco.Core/EmbeddedResources/Lang/it_ch.xml
index a8a6a718f1a1..4888f6ba35ab 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/it_ch.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/it_ch.xml
@@ -2771,18 +2771,7 @@ Per gestire il tuo sito web, è sufficiente aprire il backoffice di Umbraco e in
 		<key alias="characters_left"><![CDATA[<strong>%0%</strong> caratteri rimasti.]]></key>
 		<key alias="characters_exceed"><![CDATA[Massimo %0% caratteri, <strong>%1%</strong> di troppo.]]></key>
 	</area>
-	<area alias="recycleBin">
-		<key alias="contentTrashed">
-			Contenuto cestinato con Id: {0} relativo al contenuto principale originale con Id: {1}
-		</key>
-		<key alias="mediaTrashed">Media cestinato con Id: {0} relativo al media principale originale con Id: {1}</key>
-		<key alias="itemCannotBeRestored">Impossibile ripristinare automaticamente questo elemento</key>
-		<key alias="itemCannotBeRestoredHelpText">
-			Non esiste una posizione in cui questo elemento possa essere ripristinato
-			automaticamente. Puoi spostare l'elemento manualmente utilizzando l'albero sottostante.
-		</key>
-		<key alias="wasRestored"><![CDATA[è stato ripristinato sotto]]></key>
-	</area>
+
 	<area alias="relationType">
 		<key alias="direction">Direzione</key>
 		<key alias="parentToChild">Da genitore a figlio</key>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/nl.xml b/src/Umbraco.Core/EmbeddedResources/Lang/nl.xml
index d4835dece0ba..3630d242fe0a 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/nl.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/nl.xml
@@ -354,8 +354,4 @@
     <key alias="scheduledHealthCheckEmailBody"><![CDATA[<html><body><p>Resultaten van de geplande Umbraco Health Checks uitgevoerd op %0% op %1%:</p>%2%</body></html>]]></key>
     <key alias="scheduledHealthCheckEmailSubject">Umbraco Health Check Status: %0%</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Content verwijderd met id : {0} gerelateerd aan aan bovenliggend item met Id: {1}</key>
-    <key alias="mediaTrashed">Media verwijderd met id: {0} gerelateerd aan aan bovenliggend item met Id: {1}</key>
-  </area>
 </language>
diff --git a/src/Umbraco.Core/EmbeddedResources/Lang/tr.xml b/src/Umbraco.Core/EmbeddedResources/Lang/tr.xml
index aba49181f84e..32470eee3eca 100644
--- a/src/Umbraco.Core/EmbeddedResources/Lang/tr.xml
+++ b/src/Umbraco.Core/EmbeddedResources/Lang/tr.xml
@@ -405,8 +405,4 @@
     <key alias="scheduledHealthCheckEmailBody"><![CDATA[<html><body><p>%0% tarihinde %1% ile çalıştırılan planlanmış Umbraco Sağlık Kontrollerinin sonuçları aşağıdaki gibidir: </p>%2%</body></html>]]></key>
     <key alias="scheduledHealthCheckEmailSubject">Umbraco Sağlık Kontrolü Durumu: %0%</key>
   </area>
-  <area alias="recycleBin">
-    <key alias="contentTrashed">Çöp kutusuna gönderilmiş içerik: {0} Şu kimliğe sahip orijinal ana içerikle ilgili: {1}</key>
-    <key alias="mediaTrashed">Şu kimliğe sahip çöp kutusuna gönderilen medya: {0} Şu kimliğe sahip orijinal ana medya öğesiyle ilgili: {1}</key>
-  </area>
 </language>
diff --git a/src/Umbraco.Core/Events/AddDomainWarningsWhenPublishingNotificationHandler.cs b/src/Umbraco.Core/Events/AddDomainWarningsWhenPublishingNotificationHandler.cs
index 8cdbe8ae5f1c..3f9d4a262356 100644
--- a/src/Umbraco.Core/Events/AddDomainWarningsWhenPublishingNotificationHandler.cs
+++ b/src/Umbraco.Core/Events/AddDomainWarningsWhenPublishingNotificationHandler.cs
@@ -61,9 +61,10 @@ public void Handle(ContentPublishedNotification notification)
             }
 
             // If more than a single culture is published we need to verify that there's a domain registered for each published culture
+            // TODO: Remove int-based overload when EFCore migration is completed.
             HashSet<IDomain>? assignedDomains = content is null
                 ? null
-                : _domainService.GetAssignedDomains(content.Id, true)?.ToHashSet();
+                : _domainService.GetAssignedDomainsAsync(content.Id, true).GetAwaiter().GetResult()?.ToHashSet();
 
             IEnumerable<int>? ancestorIds = content?.GetAncestorIds();
             if (ancestorIds is not null && assignedDomains is not null)
@@ -71,7 +72,7 @@ public void Handle(ContentPublishedNotification notification)
                 // We also have to check all of the ancestors, if any of those has the appropriate culture assigned we don't need to warn
                 foreach (var ancestorID in ancestorIds)
                 {
-                    assignedDomains.UnionWith(_domainService.GetAssignedDomains(ancestorID, true) ??
+                    assignedDomains.UnionWith(_domainService.GetAssignedDomainsAsync(ancestorID, true).GetAwaiter().GetResult() ??
                                               Enumerable.Empty<IDomain>());
                 }
             }
diff --git a/src/Umbraco.Core/Events/UserNotificationsHandler.cs b/src/Umbraco.Core/Events/UserNotificationsHandler.cs
index 4d8fd66d89e3..c3e8704df7e4 100644
--- a/src/Umbraco.Core/Events/UserNotificationsHandler.cs
+++ b/src/Umbraco.Core/Events/UserNotificationsHandler.cs
@@ -220,8 +220,8 @@ public void Notify(IAction? action, params IContent[] entities)
                 if (user == null)
                 {
                     _logger.LogWarning(
-                        "Notifications can not be sent, no admin user with id {SuperUserId} could be resolved",
-                        Constants.Security.SuperUserId);
+                        "Notifications can not be sent, no admin user with id {SuperUserKey} could be resolved",
+                        Constants.Security.SuperUserKey);
                     return;
                 }
             }
diff --git a/src/Umbraco.Core/Factories/MachineInfoFactory.cs b/src/Umbraco.Core/Factories/MachineInfoFactory.cs
index 15101e30a1df..7e5dcba3bab2 100644
--- a/src/Umbraco.Core/Factories/MachineInfoFactory.cs
+++ b/src/Umbraco.Core/Factories/MachineInfoFactory.cs
@@ -1,4 +1,6 @@
 using System.Diagnostics;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Hosting;
 
 namespace Umbraco.Cms.Core.Factories;
@@ -8,19 +10,47 @@ namespace Umbraco.Cms.Core.Factories;
 /// </summary>
 internal sealed class MachineInfoFactory : IMachineInfoFactory
 {
+    // machineId is stored as NVARCHAR(255) in umbracoLastSynced
+    internal const int MaxMachineIdentifierLength = 255;
+
     private readonly IHostingEnvironment _hostingEnvironment;
+    private readonly IOptions<HostingSettings> _hostingSettings;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="MachineInfoFactory"/> class.
     /// </summary>
     /// <param name="hostingEnvironment">The hosting environment.</param>
-    public MachineInfoFactory(IHostingEnvironment hostingEnvironment)
+    /// <param name="hostingSettings">The hosting settings.</param>
+    public MachineInfoFactory(IHostingEnvironment hostingEnvironment, IOptions<HostingSettings> hostingSettings)
     {
         _hostingEnvironment = hostingEnvironment;
+        _hostingSettings = hostingSettings;
+    }
+
+    internal static string BuildMachineIdentifier(string machineName, string? siteName)
+    {
+        if (string.IsNullOrWhiteSpace(siteName))
+        {
+            return machineName;
+        }
+
+        return $"{machineName}/{siteName}";
     }
 
     /// <inheritdoc />
-    public string GetMachineIdentifier() => Environment.MachineName;
+    public string GetMachineIdentifier()
+    {
+        var identifier = BuildMachineIdentifier(Environment.MachineName, _hostingSettings.Value.SiteName);
+
+        if (identifier.Length > MaxMachineIdentifierLength)
+        {
+            throw new InvalidOperationException(
+                $"The combined machine identifier '{identifier}' ({identifier.Length} characters) exceeds the maximum allowed length of {MaxMachineIdentifierLength} characters. " +
+                $"Please shorten the value of '{Constants.Configuration.ConfigHostingPrefix}SiteName'.");
+        }
+
+        return identifier;
+    }
 
     private string? _localIdentity;
 
diff --git a/src/Umbraco.Core/Factories/UserSettingsFactory.cs b/src/Umbraco.Core/Factories/UserSettingsFactory.cs
index 1b36b3793cc0..aadf61950d4b 100644
--- a/src/Umbraco.Core/Factories/UserSettingsFactory.cs
+++ b/src/Umbraco.Core/Factories/UserSettingsFactory.cs
@@ -1,9 +1,11 @@
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Installer;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Extensions;
-using Umbraco.Cms.Core.Models.Installer;
 
 namespace Umbraco.Cms.Core.Factories;
 
@@ -13,19 +15,42 @@ namespace Umbraco.Cms.Core.Factories;
 public class UserSettingsFactory : IUserSettingsFactory
 {
     private readonly ILocalizedTextService _localizedTextService;
-    private readonly UserPasswordConfigurationSettings _passwordConfiguration;
+    private readonly SecuritySettings _securitySettings;
+    
+    // TODO (V19): Remove obsolete constructors and the ActivatorUtilitiesConstructor attribute.
+    // Also update UmbracoBuilder where this service is registered using:
+    //   services.AddTransient<IUserSettingsFactory>(sp => ActivatorUtilities.CreateInstance<UserSettingsFactory>(sp));
+    // We do this to allow the ActivatorUtilitiesConstructor to be used (it's otherwise ignored by AddTransient).
+    // Revert it to:
+    //   services.AddTransient<IUserSettingsFactory, UserSettingsFactory>();    
 
     /// <summary>
     /// Initializes a new instance of the <see cref="UserSettingsFactory"/> class.
     /// </summary>
     /// <param name="securitySettings">The user password configuration settings.</param>
     /// <param name="localizedTextService">The localized text service for retrieving localized descriptions.</param>
+    [ActivatorUtilitiesConstructor]
     public UserSettingsFactory(
-        IOptions<UserPasswordConfigurationSettings> securitySettings,
+        IOptions<SecuritySettings> securitySettings,
         ILocalizedTextService localizedTextService)
     {
         _localizedTextService = localizedTextService;
-        _passwordConfiguration = securitySettings.Value;
+        _securitySettings = securitySettings.Value;
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="UserSettingsFactory"/> class.
+    /// </summary>
+    /// <param name="securitySettings">The user password configuration settings.</param>
+    /// <param name="localizedTextService">The localized text service for retrieving localized descriptions.</param>
+    [Obsolete("Please use the constructor with all parameters. Scheduled for removal in Umbraco 19.")]
+    public UserSettingsFactory(
+        IOptions<UserPasswordConfigurationSettings> securitySettings,
+        ILocalizedTextService localizedTextService)
+        : this(
+              StaticServiceProvider.Instance.GetRequiredService<IOptions<SecuritySettings>>(),
+              localizedTextService)
+        {
     }
 
     /// <inheritdoc />
@@ -43,8 +68,8 @@ public UserSettingsModel GetUserSettings() =>
     private PasswordSettingsModel CreatePasswordSettingsModel() =>
         new()
         {
-            MinCharLength = _passwordConfiguration.RequiredLength,
-            MinNonAlphaNumericLength = _passwordConfiguration.GetMinNonAlphaNumericChars()
+            MinCharLength = _securitySettings.UserPassword.RequiredLength,
+            MinNonAlphaNumericLength = _securitySettings.UserPassword.GetMinNonAlphaNumericChars()
         };
 
     /// <summary>
diff --git a/src/Umbraco.Core/HealthChecks/Checks/Security/BaseHttpHeaderCheck.cs b/src/Umbraco.Core/HealthChecks/Checks/Security/BaseHttpHeaderCheck.cs
index c9467a408a39..41fc3c5860f3 100644
--- a/src/Umbraco.Core/HealthChecks/Checks/Security/BaseHttpHeaderCheck.cs
+++ b/src/Umbraco.Core/HealthChecks/Checks/Security/BaseHttpHeaderCheck.cs
@@ -79,6 +79,16 @@ protected async Task<HealthCheckStatus> CheckForHeader()
         // Access the site home page and check for the click-jack protection header or meta tag
         var url = _hostingEnvironment.ApplicationMainUrl?.GetLeftPart(UriPartial.Authority);
 
+        if (url is null)
+        {
+            return new HealthCheckStatus(
+                LocalizedTextService.Localize("healthcheck", "httpsCheckNoApplicationUrl"))
+            {
+                ResultType = StatusResultType.Info,
+                ReadMoreLink = ReadMoreLink,
+            };
+        }
+
         try
         {
             using HttpResponseMessage response = await HttpClient.GetAsync(url);
diff --git a/src/Umbraco.Core/HealthChecks/Checks/Security/ExcessiveHeadersCheck.cs b/src/Umbraco.Core/HealthChecks/Checks/Security/ExcessiveHeadersCheck.cs
index 37d46d00e3e8..52141bec6146 100644
--- a/src/Umbraco.Core/HealthChecks/Checks/Security/ExcessiveHeadersCheck.cs
+++ b/src/Umbraco.Core/HealthChecks/Checks/Security/ExcessiveHeadersCheck.cs
@@ -46,6 +46,16 @@ private async Task<HealthCheckStatus> CheckForHeaders()
         var success = false;
         var url = _hostingEnvironment.ApplicationMainUrl?.GetLeftPart(UriPartial.Authority);
 
+        if (url is null)
+        {
+            return new HealthCheckStatus(
+                _textService.Localize("healthcheck", "httpsCheckNoApplicationUrl"))
+            {
+                ResultType = StatusResultType.Info,
+                ReadMoreLink = Constants.HealthChecks.DocumentationLinks.Security.ExcessiveHeadersCheck,
+            };
+        }
+
         // Access the site home page and check for the headers
         using var request = new HttpRequestMessage(HttpMethod.Head, url);
         try
diff --git a/src/Umbraco.Core/HealthChecks/Checks/Security/HttpsCheck.cs b/src/Umbraco.Core/HealthChecks/Checks/Security/HttpsCheck.cs
index c13ade6ea1db..444243b0c461 100644
--- a/src/Umbraco.Core/HealthChecks/Checks/Security/HttpsCheck.cs
+++ b/src/Umbraco.Core/HealthChecks/Checks/Security/HttpsCheck.cs
@@ -74,8 +74,27 @@ private static bool ServerCertificateCustomValidation(
         return sslErrors == SslPolicyErrors.None;
     }
 
+    private HealthCheckStatus? CheckApplicationUrlAvailable()
+    {
+        if (_hostingEnvironment.ApplicationMainUrl is not null)
+        {
+            return null;
+        }
+
+        return new HealthCheckStatus(
+            _textService.Localize("healthcheck", "httpsCheckNoApplicationUrl"))
+        {
+            ResultType = StatusResultType.Info,
+        };
+    }
+
     private async Task<HealthCheckStatus> CheckForValidCertificate()
     {
+        if (CheckApplicationUrlAvailable() is HealthCheckStatus unavailable)
+        {
+            return unavailable;
+        }
+
         string message;
         StatusResultType result;
 
@@ -154,6 +173,11 @@ private async Task<HealthCheckStatus> CheckForValidCertificate()
 
     private Task<HealthCheckStatus> CheckIfCurrentSchemeIsHttps()
     {
+        if (CheckApplicationUrlAvailable() is HealthCheckStatus unavailable)
+        {
+            return Task.FromResult(unavailable);
+        }
+
         Uri uri = _hostingEnvironment.ApplicationMainUrl;
         var success = uri.Scheme == Uri.UriSchemeHttps;
 
@@ -169,6 +193,11 @@ private Task<HealthCheckStatus> CheckIfCurrentSchemeIsHttps()
 
     private Task<HealthCheckStatus> CheckHttpsConfigurationSetting()
     {
+        if (CheckApplicationUrlAvailable() is HealthCheckStatus unavailable)
+        {
+            return Task.FromResult(unavailable);
+        }
+
         var httpsSettingEnabled = _globalSettings.CurrentValue.UseHttps;
         Uri uri = _hostingEnvironment.ApplicationMainUrl;
 
diff --git a/src/Umbraco.Core/Hosting/IHostingEnvironment.cs b/src/Umbraco.Core/Hosting/IHostingEnvironment.cs
index f2b187b0443d..ad507255af65 100644
--- a/src/Umbraco.Core/Hosting/IHostingEnvironment.cs
+++ b/src/Umbraco.Core/Hosting/IHostingEnvironment.cs
@@ -83,6 +83,7 @@ public interface IHostingEnvironment
     /// <summary>
     ///     Gets the main application url.
     /// </summary>
+    // TODO (V18): Change to Uri? to reflect that this can be null when ApplicationUrlDetection is None and no explicit URL is configured.
     Uri ApplicationMainUrl { get; }
 
     /// <summary>
diff --git a/src/Umbraco.Core/IO/PhysicalFileSystem.cs b/src/Umbraco.Core/IO/PhysicalFileSystem.cs
index f829e630bc29..26d087b822b5 100644
--- a/src/Umbraco.Core/IO/PhysicalFileSystem.cs
+++ b/src/Umbraco.Core/IO/PhysicalFileSystem.cs
@@ -578,7 +578,11 @@ protected void WithRetry(Action action)
     /// Creates a file provider.
     /// </summary>
     /// <returns>The file provider.</returns>
-    public IFileProvider Create() => new PhysicalFileProvider(_rootPath);
+    public IFileProvider Create()
+    {
+        Directory.CreateDirectory(_rootPath);
+        return new PhysicalFileProvider(_rootPath);
+    }
 
     #endregion
 }
diff --git a/src/Umbraco.Core/Media/ISvgDimensionExtractor.cs b/src/Umbraco.Core/Media/ISvgDimensionExtractor.cs
new file mode 100644
index 000000000000..31fdcde1641d
--- /dev/null
+++ b/src/Umbraco.Core/Media/ISvgDimensionExtractor.cs
@@ -0,0 +1,18 @@
+using System.Drawing;
+
+namespace Umbraco.Cms.Core.Media;
+
+/// <summary>
+/// Extracts image dimensions from an SVG stream.
+/// </summary>
+public interface ISvgDimensionExtractor
+{
+    /// <summary>
+    /// Gets the dimensions.
+    /// </summary>
+    /// <param name="stream">The stream.</param>
+    /// <returns>
+    /// The dimensions of the image if the stream was parsable; otherwise, <c>null</c>.
+    /// </returns>
+    public Size? GetDimensions(Stream stream);
+}
diff --git a/src/Umbraco.Core/Models/Blocks/BlockLayoutItemBase.cs b/src/Umbraco.Core/Models/Blocks/BlockLayoutItemBase.cs
index 904f22270fe9..dc4ffc2f6aed 100644
--- a/src/Umbraco.Core/Models/Blocks/BlockLayoutItemBase.cs
+++ b/src/Umbraco.Core/Models/Blocks/BlockLayoutItemBase.cs
@@ -5,59 +5,11 @@ namespace Umbraco.Cms.Core.Models.Blocks;
 /// </summary>
 public abstract class BlockLayoutItemBase : IBlockLayoutItem
 {
-    private Guid? _contentKey;
-    private Guid? _settingsKey;
-
-    private Udi? _contentUdi;
-    private Udi? _settingsUdi;
-
-    /// <inheritdoc />
-    [Obsolete("Use ContentKey instead. Scheduled for removal in Umbraco 18.")]
-    public Udi? ContentUdi
-    {
-        get => _contentUdi;
-        set
-        {
-            if (_contentKey is not null)
-            {
-                return;
-            }
-
-            _contentUdi = value;
-            _contentKey = (value as GuidUdi)?.Guid;
-        }
-    }
-
     /// <inheritdoc />
-    [Obsolete("Use SettingsKey instead. Scheduled for removal in Umbraco 18.")]
-    public Udi? SettingsUdi
-    {
-        get => _settingsUdi;
-        set
-        {
-            if (_settingsKey is not null)
-            {
-                return;
-            }
-
-            _settingsUdi = value;
-            _settingsKey = (value as GuidUdi)?.Guid;
-        }
-    }
-
-    /// <inheritdoc />
-    public Guid ContentKey
-    {
-        get => _contentKey ?? throw new InvalidOperationException("ContentKey has not yet been initialized");
-        set => _contentKey = value;
-    }
+    public Guid ContentKey { get; set; }
 
     /// <inheritdoc />
-    public Guid? SettingsKey
-    {
-        get => _settingsKey;
-        set => _settingsKey = value;
-    }
+    public Guid? SettingsKey { get; set; }
 
     /// <summary>
     ///     Initializes a new instance of the <see cref="BlockLayoutItemBase" /> class.
@@ -65,29 +17,6 @@ public Guid? SettingsKey
     protected BlockLayoutItemBase()
     { }
 
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="BlockLayoutItemBase" /> class.
-    /// </summary>
-    /// <param name="contentUdi">The content UDI.</param>
-    [Obsolete("Use constructor that accepts GUIDs instead. Scheduled for removal in Umbraco 18.")]
-    protected BlockLayoutItemBase(Udi contentUdi)
-        : this((contentUdi as GuidUdi)?.Guid ?? throw new ArgumentException(nameof(contentUdi)))
-    {
-    }
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="BlockLayoutItemBase" /> class.
-    /// </summary>
-    /// <param name="contentUdi">The content UDI.</param>
-    /// <param name="settingsUdi">The settings UDI.</param>
-    [Obsolete("Use constructor that accepts GUIDs instead. Scheduled for removal in Umbraco 18.")]
-    protected BlockLayoutItemBase(Udi contentUdi, Udi settingsUdi)
-        : this(
-            (contentUdi as GuidUdi)?.Guid ?? throw new ArgumentException(nameof(contentUdi)),
-            (settingsUdi as GuidUdi)?.Guid ?? throw new ArgumentException(nameof(settingsUdi)))
-    {
-    }
-
     /// <summary>
     ///     Initializes a new instance of the <see cref="BlockLayoutItemBase" /> class.
     /// </summary>
@@ -95,7 +24,6 @@ protected BlockLayoutItemBase(Udi contentUdi, Udi settingsUdi)
     protected BlockLayoutItemBase(Guid contentKey)
     {
         ContentKey = contentKey;
-        ContentUdi = new GuidUdi(Constants.UdiEntityType.Element, contentKey);
     }
 
     /// <summary>
@@ -107,7 +35,6 @@ protected BlockLayoutItemBase(Guid contentKey, Guid settingsKey)
         : this(contentKey)
     {
         SettingsKey = settingsKey;
-        SettingsUdi = new GuidUdi(Constants.UdiEntityType.Element, settingsKey);
     }
 
     /// <inheritdoc />
diff --git a/src/Umbraco.Core/Models/Blocks/ContentAndSettingsReference.cs b/src/Umbraco.Core/Models/Blocks/ContentAndSettingsReference.cs
index 0d8880fabaa4..6897a13dcf32 100644
--- a/src/Umbraco.Core/Models/Blocks/ContentAndSettingsReference.cs
+++ b/src/Umbraco.Core/Models/Blocks/ContentAndSettingsReference.cs
@@ -17,30 +17,8 @@ public ContentAndSettingsReference(Guid contentKey, Guid? settingsKey)
     {
         ContentKey = contentKey;
         SettingsKey = settingsKey;
-        ContentUdi = new GuidUdi(Constants.UdiEntityType.Element, contentKey);
-        SettingsUdi = settingsKey.HasValue
-            ? new GuidUdi(Constants.UdiEntityType.Element, settingsKey.Value)
-            : null;
     }
 
-    /// <summary>
-    ///     Gets the content UDI.
-    /// </summary>
-    /// <value>
-    ///     The content UDI.
-    /// </value>
-    [Obsolete("Use ContentKey instead. Scheduled for removal in Umbraco 18.")]
-    public Udi ContentUdi { get; }
-
-    /// <summary>
-    ///     Gets the settings UDI.
-    /// </summary>
-    /// <value>
-    ///     The settings UDI.
-    /// </value>
-    [Obsolete("Use SettingsKey instead. Scheduled for removal in Umbraco 18.")]
-    public Udi? SettingsUdi { get; }
-
     /// <summary>
     ///     Gets or sets the content key.
     /// </summary>
@@ -73,15 +51,11 @@ public ContentAndSettingsReference(Guid contentKey, Guid? settingsKey)
 
     /// <inheritdoc />
     public bool Equals(ContentAndSettingsReference other) => other != null
-                                                             && EqualityComparer<Udi>.Default.Equals(
-                                                                 ContentUdi,
-                                                                 other.ContentUdi)
-                                                             && EqualityComparer<Udi>.Default.Equals(
-                                                                 SettingsUdi,
-                                                                 other.SettingsUdi);
+                                                             && ContentKey.Equals(other.ContentKey)
+                                                             && SettingsKey.Equals(other.SettingsKey);
 
     /// <inheritdoc />
-    public override int GetHashCode() => (ContentUdi, SettingsUdi).GetHashCode();
+    public override int GetHashCode() => (ContentKey, SettingsKey).GetHashCode();
 
     /// <summary>
     ///     Determines whether two <see cref="ContentAndSettingsReference" /> instances are not equal.
diff --git a/src/Umbraco.Core/Models/ContentTypeBase.cs b/src/Umbraco.Core/Models/ContentTypeBase.cs
index 5a245383e8fe..4666baf9cecb 100644
--- a/src/Umbraco.Core/Models/ContentTypeBase.cs
+++ b/src/Umbraco.Core/Models/ContentTypeBase.cs
@@ -506,9 +506,11 @@ public override void ResetDirtyProperties()
     public IContentTypeBase DeepCloneWithResetIdentities(string alias)
     {
         var clone = (IContentTypeBase)DeepClone();
+
+        // ResetIdentity() must be called before setting the alias, because HasIdentity
+        // is used by system content types to guard against alias changes.
         clone.ResetIdentity();
         clone.Alias = alias;
-
         foreach (PropertyGroup propertyGroup in clone.PropertyGroups)
         {
             propertyGroup.ResetIdentity();
diff --git a/src/Umbraco.Core/Models/ContentTypeCompositionBase.cs b/src/Umbraco.Core/Models/ContentTypeCompositionBase.cs
index 9d0ba6308478..e7d590c1ce1f 100644
--- a/src/Umbraco.Core/Models/ContentTypeCompositionBase.cs
+++ b/src/Umbraco.Core/Models/ContentTypeCompositionBase.cs
@@ -14,6 +14,7 @@ public abstract class ContentTypeCompositionBase : ContentTypeBase, IContentType
     private List<IContentTypeComposition> _contentTypeComposition = new();
     private List<int> _removedContentTypeKeyTracker = new();
     private bool _hasCompositionBeenRemoved;
+    private bool _hasCompositionBeenAdded;
 
     /// <summary>
     ///     Initializes a new instance of the <see cref="ContentTypeCompositionBase" /> class with the specified parent ID.
@@ -142,6 +143,24 @@ private set
         }
     }
 
+    /// <summary>
+    ///     A boolean flag indicating if a composition has been added to this instance.
+    /// </summary>
+    /// <remarks>
+    ///     This is used in order to know that we need to raise the correct content type change flags
+    ///     when a composition has been added to a content type.
+    /// </remarks>
+    [IgnoreDataMember]
+    internal bool HasCompositionTypeBeenAdded
+    {
+        get => _hasCompositionBeenAdded;
+        private set
+        {
+            _hasCompositionBeenAdded = value;
+            OnPropertyChanged(nameof(HasCompositionTypeBeenAdded));
+        }
+    }
+
     /// <inheritdoc />
     public IEnumerable<IPropertyType> GetOriginalComposedPropertyTypes() => GetRawComposedPropertyTypes();
 
@@ -183,6 +202,7 @@ public bool AddContentType(IContentTypeComposition? contentType)
 
             _contentTypeComposition.Add(contentType);
 
+            HasCompositionTypeBeenAdded = true;
             OnPropertyChanged(nameof(ContentTypeComposition));
 
             return true;
diff --git a/src/Umbraco.Core/Models/DeliveryApi/ApiLink.cs b/src/Umbraco.Core/Models/DeliveryApi/ApiLink.cs
index fd538909f61e..a2d2bc593316 100644
--- a/src/Umbraco.Core/Models/DeliveryApi/ApiLink.cs
+++ b/src/Umbraco.Core/Models/DeliveryApi/ApiLink.cs
@@ -19,20 +19,6 @@ public sealed class ApiLink
     public static ApiLink Content(string title, string? queryString, string? target, Guid destinationId, string destinationType, IApiContentRoute route, string? culture = null)
        => new(LinkType.Content, url: null, queryString, title, target, destinationId, destinationType, route, culture);
 
-    /// <summary>
-    ///     Creates a link to content.
-    /// </summary>
-    /// <param name="title">The title of the link.</param>
-    /// <param name="queryString">The query string of the link.</param>
-    /// <param name="target">The target attribute of the link (e.g., "_blank").</param>
-    /// <param name="destinationId">The unique identifier of the destination content.</param>
-    /// <param name="destinationType">The content type alias of the destination.</param>
-    /// <param name="route">The route information for the destination content.</param>
-    /// <returns>A new <see cref="ApiLink" /> instance representing a content link.</returns>
-    [Obsolete("Please use the constructor taking all parameters. Scheduled for removal in Umbraco 18.")]
-    public static ApiLink Content(string title, string? queryString, string? target, Guid destinationId, string destinationType, IApiContentRoute route)
-        => new(LinkType.Content, url: null, queryString, title, target, destinationId, destinationType, route);
-
     /// <summary>
     ///     Creates a link to media.
     /// </summary>
diff --git a/src/Umbraco.Core/Models/IDomain.cs b/src/Umbraco.Core/Models/IDomain.cs
index edfff6512e5a..fc18f8b4e813 100644
--- a/src/Umbraco.Core/Models/IDomain.cs
+++ b/src/Umbraco.Core/Models/IDomain.cs
@@ -49,6 +49,14 @@ public interface IDomain : IEntity, IRememberBeingDirty
     /// </value>
     int? RootContentId { get; set; }
 
+    /// <summary>
+    /// Gets or sets the key of the root content assigned to the domain.
+    /// </summary>
+    /// <value>
+    /// The root content key, or <c>null</c> if no content is assigned.
+    /// </value>
+    Guid? RootContentKey { get; set; }
+
     /// <summary>
     /// Gets or sets the sort order.
     /// </summary>
diff --git a/src/Umbraco.Core/Models/MediaType.cs b/src/Umbraco.Core/Models/MediaType.cs
index 4ae79c7a1e5b..41e3ad546f26 100644
--- a/src/Umbraco.Core/Models/MediaType.cs
+++ b/src/Umbraco.Core/Models/MediaType.cs
@@ -15,7 +15,6 @@ public class MediaType : ContentTypeCompositionBase, IMediaType
     ///     Constant indicating that media types do not support publishing.
     /// </summary>
     public const bool SupportsPublishingConst = false;
-    private bool _isCloning;
 
     /// <summary>
     ///     Constuctor for creating a MediaType with the parent's id.
@@ -56,7 +55,7 @@ public override string Alias
         get => base.Alias;
         set
         {
-            if (this.IsSystemMediaType() && value != Alias && _isCloning is false)
+            if (HasIdentity && this.IsSystemMediaType() && value != Alias)
             {
                 throw new InvalidOperationException("Cannot change the alias of a system media type");
             }
@@ -66,12 +65,7 @@ public override string Alias
     }
 
     /// <inheritdoc />
-    public new IMediaType DeepCloneWithResetIdentities(string newAlias)
-    {
-        _isCloning = true;
-        var clone = (IMediaType)base.DeepCloneWithResetIdentities(newAlias);
-        _isCloning = false;
-        return clone;
-    }
+    public new IMediaType DeepCloneWithResetIdentities(string newAlias) =>
+        (IMediaType)base.DeepCloneWithResetIdentities(newAlias);
 
 }
diff --git a/src/Umbraco.Core/Models/PublishedContent/VariationContextAccessorExtensions.cs b/src/Umbraco.Core/Models/PublishedContent/VariationContextAccessorExtensions.cs
index adafe3115684..66d906191c51 100644
--- a/src/Umbraco.Core/Models/PublishedContent/VariationContextAccessorExtensions.cs
+++ b/src/Umbraco.Core/Models/PublishedContent/VariationContextAccessorExtensions.cs
@@ -27,23 +27,6 @@ public static void ContextualizeVariation(
         ref string? segment)
         => variationContextAccessor.ContextualizeVariation(variations, null, propertyAlias, ref culture, ref segment);
 
-    /// <summary>
-    ///     Contextualizes the variation based on the content variation settings and content ID.
-    /// </summary>
-    /// <param name="variationContextAccessor">The variation context accessor.</param>
-    /// <param name="variations">The content variation settings.</param>
-    /// <param name="contentId">The content ID.</param>
-    /// <param name="culture">The culture, which may be set based on the variation context.</param>
-    /// <param name="segment">The segment, which may be set based on the variation context.</param>
-    [Obsolete("Please use the method overload that accepts all parameters. Scheduled for removal in Umbraco 18.")]
-    public static void ContextualizeVariation(
-        this IVariationContextAccessor variationContextAccessor,
-        ContentVariation variations,
-        int contentId,
-        ref string? culture,
-        ref string? segment)
-        => variationContextAccessor.ContextualizeVariation(variations, (int?)contentId, null, ref culture, ref segment);
-
     /// <summary>
     ///     Contextualizes the variation based on the content variation settings, content ID, and property alias.
     /// </summary>
diff --git a/src/Umbraco.Core/Models/PublishedDocumentUrlAlias.cs b/src/Umbraco.Core/Models/PublishedDocumentUrlAlias.cs
index 6cfc59ee4771..e897957d0c8c 100644
--- a/src/Umbraco.Core/Models/PublishedDocumentUrlAlias.cs
+++ b/src/Umbraco.Core/Models/PublishedDocumentUrlAlias.cs
@@ -10,24 +10,10 @@ public class PublishedDocumentUrlAlias
     /// </summary>
     public required Guid DocumentKey { get; set; }
 
-    /// <summary>
-    /// Gets or sets the language Id.
-    /// </summary>
-    /// <remarks>
-    /// This property returns 0 for invariant content. Use <see cref="NullableLanguageId"/> instead,
-    /// which correctly returns <c>null</c> for invariant content.
-    /// </remarks>
-    [Obsolete("Use NullableLanguageId instead. This property returns 0 for invariant content. Scheduled for removal in Umbraco 18, when the NullableLanguageId will also be renamed to LanguageId.")]
-    public int LanguageId
-    {
-        get => NullableLanguageId ?? 0;
-        set => NullableLanguageId = value;
-    }
-
     /// <summary>
     /// Gets or sets the language Id. NULL indicates invariant content (not language-specific).
     /// </summary>
-    public required int? NullableLanguageId { get; set; }
+    public required int? LanguageId { get; set; }
 
     /// <summary>
     /// Gets or sets the normalized URL alias (lowercase, no leading slash).
diff --git a/src/Umbraco.Core/Models/PublishedDocumentUrlSegment.cs b/src/Umbraco.Core/Models/PublishedDocumentUrlSegment.cs
index 1ca63d58e200..87f514fa2ca8 100644
--- a/src/Umbraco.Core/Models/PublishedDocumentUrlSegment.cs
+++ b/src/Umbraco.Core/Models/PublishedDocumentUrlSegment.cs
@@ -10,24 +10,10 @@ public class PublishedDocumentUrlSegment
     /// </summary>
     public required Guid DocumentKey { get; set; }
 
-    /// <summary>
-    /// Gets or sets the language Id.
-    /// </summary>
-    /// <remarks>
-    /// This property returns 0 for invariant content. Use <see cref="NullableLanguageId"/> instead,
-    /// which correctly returns <c>null</c> for invariant content.
-    /// </remarks>
-    [Obsolete("Use NullableLanguageId instead. This property returns 0 for invariant content. Scheduled for removal in Umbraco 18, when the NullableLanguageId will also be renamed to LanguageId.")]
-    public int LanguageId
-    {
-        get => NullableLanguageId ?? 0;
-        set => NullableLanguageId = value;
-    }
-
     /// <summary>
     /// Gets or sets the language Id. NULL indicates invariant content (not language-specific).
     /// </summary>
-    public required int? NullableLanguageId { get; set; }
+    public required int? LanguageId { get; set; }
 
     /// <summary>
     /// Gets or sets the URL segment string.
diff --git a/src/Umbraco.Core/Models/UmbracoDomain.cs b/src/Umbraco.Core/Models/UmbracoDomain.cs
index f9c3cd753de4..1b0143a3a301 100644
--- a/src/Umbraco.Core/Models/UmbracoDomain.cs
+++ b/src/Umbraco.Core/Models/UmbracoDomain.cs
@@ -51,6 +51,9 @@ public int? LanguageId
     /// <inheritdoc />
     public string? LanguageIsoCode { get; set; }
 
+    /// <inheritdoc />
+    public Guid? RootContentKey { get; set; }
+
     /// <inheritdoc />
     [DataMember]
     public int? RootContentId
diff --git a/src/Umbraco.Core/Models/UmbracoUserExtensions.cs b/src/Umbraco.Core/Models/UmbracoUserExtensions.cs
index 894d48401a07..8a36ee4ce2c2 100644
--- a/src/Umbraco.Core/Models/UmbracoUserExtensions.cs
+++ b/src/Umbraco.Core/Models/UmbracoUserExtensions.cs
@@ -46,7 +46,7 @@ public static bool IsSuper(this IUser user)
             throw new ArgumentNullException(nameof(user));
         }
 
-        return user.Id == Constants.Security.SuperUserId;
+        return user.Key == Constants.Security.SuperUserKey;
     }
 
     /// <summary>
diff --git a/src/Umbraco.Core/Notifications/ContentCopiedNotification.cs b/src/Umbraco.Core/Notifications/ContentCopiedNotification.cs
index c82a4e73c0d1..bd2d2ce2c0a1 100644
--- a/src/Umbraco.Core/Notifications/ContentCopiedNotification.cs
+++ b/src/Umbraco.Core/Notifications/ContentCopiedNotification.cs
@@ -24,8 +24,23 @@ public sealed class ContentCopiedNotification : CopiedNotification<IContent>
     /// <param name="parentKey">The key of the new parent.</param>
     /// <param name="relateToOriginal">A value indicating whether the copy is related to the original.</param>
     /// <param name="messages">The event messages collection.</param>
+    public ContentCopiedNotification(IContent original, IContent copy, Guid? parentKey, bool relateToOriginal, EventMessages messages)
+        : base(original, copy, parentKey, relateToOriginal, messages)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="ContentCopiedNotification"/> class.
+    /// </summary>
+    /// <param name="original">The original content item that was copied.</param>
+    /// <param name="copy">The copy of the content item.</param>
+    /// <param name="parentId">The ID of the new parent.</param>
+    /// <param name="parentKey">The key of the new parent.</param>
+    /// <param name="relateToOriginal">A value indicating whether the copy is related to the original.</param>
+    /// <param name="messages">The event messages collection.</param>
+    [Obsolete("Use the constructor without parentId parameter instead. Scheduled for removal in Umbraco 20.")]
     public ContentCopiedNotification(IContent original, IContent copy, int parentId, Guid? parentKey, bool relateToOriginal, EventMessages messages)
-        : base(original, copy, parentId, parentKey, relateToOriginal, messages)
+        : this(original, copy, parentKey, relateToOriginal, messages)
     {
     }
 }
diff --git a/src/Umbraco.Core/Notifications/ContentCopyingNotification.cs b/src/Umbraco.Core/Notifications/ContentCopyingNotification.cs
index bc7bfc50726a..994a7447a676 100644
--- a/src/Umbraco.Core/Notifications/ContentCopyingNotification.cs
+++ b/src/Umbraco.Core/Notifications/ContentCopyingNotification.cs
@@ -24,8 +24,22 @@ public sealed class ContentCopyingNotification : CopyingNotification<IContent>
     /// <param name="parentId">The ID of the new parent.</param>
     /// <param name="parentKey">The key of the new parent.</param>
     /// <param name="messages">The event messages collection.</param>
+    public ContentCopyingNotification(IContent original, IContent copy, Guid? parentKey, EventMessages messages)
+        : base(original, copy, parentKey, messages)
+    {
+    }
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="ContentCopyingNotification"/> class.
+    /// </summary>
+    /// <param name="original">The original content item being copied.</param>
+    /// <param name="copy">The copy of the content item.</param>
+    /// <param name="parentId">The ID of the new parent.</param>
+    /// <param name="parentKey">The key of the new parent.</param>
+    /// <param name="messages">The event messages collection.</param>
+    [Obsolete("Please use the constructor without parentId instead. Scheduled for removal in Umbraco 20.")]
     public ContentCopyingNotification(IContent original, IContent copy, int parentId, Guid? parentKey, EventMessages messages)
-        : base(original, copy, parentId, parentKey, messages)
+        : this(original, copy, parentKey, messages)
     {
     }
 }
diff --git a/src/Umbraco.Core/Notifications/CopiedNotification.cs b/src/Umbraco.Core/Notifications/CopiedNotification.cs
index 429c8299b895..08bf6333de6a 100644
--- a/src/Umbraco.Core/Notifications/CopiedNotification.cs
+++ b/src/Umbraco.Core/Notifications/CopiedNotification.cs
@@ -17,23 +17,36 @@ public abstract class CopiedNotification<T> : ObjectNotification<T>
     where T : class
 {
     /// <summary>
-    ///     Initializes a new instance of the <see cref="CopiedNotification{T}"/> class.
+    /// Initializes a new instance of the <see cref="CopiedNotification{T}"/> class.
     /// </summary>
     /// <param name="original">The original entity that was copied.</param>
     /// <param name="copy">The copy of the entity.</param>
-    /// <param name="parentId">The ID of the new parent.</param>
     /// <param name="parentKey">The key of the new parent.</param>
     /// <param name="relateToOriginal">A value indicating whether the copy is related to the original.</param>
     /// <param name="messages">The event messages collection.</param>
-    protected CopiedNotification(T original, T copy, int parentId, Guid? parentKey, bool relateToOriginal, EventMessages messages)
-        : base(original, messages)
+    protected CopiedNotification(T original, T copy, Guid? parentKey, bool relateToOriginal, EventMessages messages)
+    : base(original, messages)
     {
         Copy = copy;
-        ParentId = parentId;
         ParentKey = parentKey;
         RelateToOriginal = relateToOriginal;
     }
 
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="CopiedNotification{T}"/> class.
+    /// </summary>
+    /// <param name="original">The original entity that was copied.</param>
+    /// <param name="copy">The copy of the entity.</param>
+    /// <param name="parentId">The ID of the new parent.</param>
+    /// <param name="parentKey">The key of the new parent.</param>
+    /// <param name="relateToOriginal">A value indicating whether the copy is related to the original.</param>
+    /// <param name="messages">The event messages collection.</param>
+    [Obsolete("Use the constructor without parentId parameter instead. Scheduled for removal in Umbraco 20.")]
+    protected CopiedNotification(T original, T copy, int parentId, Guid? parentKey, bool relateToOriginal, EventMessages messages)
+        : this(original, copy, parentKey, relateToOriginal, messages)
+    {
+    }
+
     /// <summary>
     ///     Gets the original entity that was copied.
     /// </summary>
@@ -44,12 +57,6 @@ protected CopiedNotification(T original, T copy, int parentId, Guid? parentKey,
     /// </summary>
     public T Copy { get; }
 
-    /// <summary>
-    ///     Gets the ID of the new parent.
-    /// </summary>
-    [Obsolete("Please use parent key instead. Scheduled for removal in Umbraco 18.")]
-    public int ParentId { get; }
-
     /// <summary>
     ///     Gets the key of the new parent.
     /// </summary>
diff --git a/src/Umbraco.Core/Notifications/CopyingNotification.cs b/src/Umbraco.Core/Notifications/CopyingNotification.cs
index 8135f611c8b8..59cde529d7f3 100644
--- a/src/Umbraco.Core/Notifications/CopyingNotification.cs
+++ b/src/Umbraco.Core/Notifications/CopyingNotification.cs
@@ -21,17 +21,29 @@ public abstract class CopyingNotification<T> : CancelableObjectNotification<T>
     /// </summary>
     /// <param name="original">The original entity being copied.</param>
     /// <param name="copy">The copy of the entity.</param>
-    /// <param name="parentId">The ID of the new parent.</param>
     /// <param name="parentKey">The key of the new parent.</param>
     /// <param name="messages">The event messages collection.</param>
-    protected CopyingNotification(T original, T copy, int parentId, Guid? parentKey, EventMessages messages)
+    protected CopyingNotification(T original, T copy, Guid? parentKey, EventMessages messages)
         : base(original, messages)
     {
         Copy = copy;
-        ParentId = parentId;
         ParentKey = parentKey;
     }
 
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="CopyingNotification{T}"/> class.
+    /// </summary>
+    /// <param name="original">The original entity being copied.</param>
+    /// <param name="copy">The copy of the entity.</param>
+    /// <param name="parentId">The ID of the new parent.</param>
+    /// <param name="parentKey">The key of the new parent.</param>
+    /// <param name="messages">The event messages collection.</param>
+    [Obsolete("Please use the constructor without parentId instead. Scheduled for removal in Umbraco 20.")]
+    protected CopyingNotification(T original, T copy, int parentId, Guid? parentKey, EventMessages messages)
+        : this (original, copy, parentKey, messages)
+    {
+    }
+
     /// <summary>
     ///     Gets the original entity being copied.
     /// </summary>
@@ -42,12 +54,6 @@ protected CopyingNotification(T original, T copy, int parentId, Guid? parentKey,
     /// </summary>
     public T Copy { get; }
 
-    /// <summary>
-    ///     Gets the ID of the new parent.
-    /// </summary>
-    [Obsolete("Please use parent key instead. Scheduled for removal in Umbraco 18.")]
-    public int ParentId { get; }
-
     /// <summary>
     ///     Gets the key of the new parent.
     /// </summary>
diff --git a/src/Umbraco.Core/Notifications/ElementCopiedNotification.cs b/src/Umbraco.Core/Notifications/ElementCopiedNotification.cs
index 22a4e61d1245..5433069142e4 100644
--- a/src/Umbraco.Core/Notifications/ElementCopiedNotification.cs
+++ b/src/Umbraco.Core/Notifications/ElementCopiedNotification.cs
@@ -8,8 +8,14 @@ namespace Umbraco.Cms.Core.Notifications;
 /// </summary>
 public sealed class ElementCopiedNotification : CopiedNotification<IElement>
 {
+    public ElementCopiedNotification(IElement original, IElement copy, Guid? parentKey, bool relateToOriginal, EventMessages messages)
+        : base(original, copy, parentKey, relateToOriginal, messages)
+    {
+    }
+
+    [Obsolete("Use the constructor without parentId parameter instead. Scheduled for removal in Umbraco 20.")]
     public ElementCopiedNotification(IElement original, IElement copy, int parentId, Guid? parentKey, bool relateToOriginal, EventMessages messages)
-        : base(original, copy, parentId, parentKey, relateToOriginal, messages)
+        : this (original, copy, parentKey, relateToOriginal, messages)
     {
     }
 }
diff --git a/src/Umbraco.Core/Notifications/ElementCopyingNotification.cs b/src/Umbraco.Core/Notifications/ElementCopyingNotification.cs
index a9f14c6858a3..44de70560622 100644
--- a/src/Umbraco.Core/Notifications/ElementCopyingNotification.cs
+++ b/src/Umbraco.Core/Notifications/ElementCopyingNotification.cs
@@ -8,8 +8,14 @@ namespace Umbraco.Cms.Core.Notifications;
 /// </summary>
 public sealed class ElementCopyingNotification : CopyingNotification<IElement>
 {
+    public ElementCopyingNotification(IElement original, IElement copy, Guid? parentKey, EventMessages messages)
+        : base(original, copy, parentKey, messages)
+    {
+    }
+
+    [Obsolete("Please use the constructor without parentId instead. Scheduled for removal in Umbraco 20.")]
     public ElementCopyingNotification(IElement original, IElement copy, int parentId, Guid? parentKey, EventMessages messages)
-        : base(original, copy, parentId, parentKey, messages)
+        : this(original, copy, parentKey, messages)
     {
     }
 }
diff --git a/src/Umbraco.Core/Persistence/Repositories/IContentVersionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/IContentVersionRepository.cs
index fc7158f097b0..8e3b1048a879 100644
--- a/src/Umbraco.Core/Persistence/Repositories/IContentVersionRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/IContentVersionRepository.cs
@@ -5,9 +5,12 @@ namespace Umbraco.Cms.Core.Persistence.Repositories;
 public interface IContentVersionRepository : IRepository
 {
     /// <summary>
-    ///     Gets a list of all historic content versions.
+    ///     Gets content versions eligible for cleanup, filtered to those older than the
+    ///     specified date and limited to a maximum number of results, ordered oldest first.
     /// </summary>
-    IReadOnlyCollection<ContentVersionMeta> GetContentVersionsEligibleForCleanup();
+    /// <param name="olderThan">Only versions with a date earlier than this are returned.</param>
+    /// <param name="maxCount">The maximum number of versions to return, or <c>null</c> for no limit.</param>
+    IReadOnlyCollection<ContentVersionMeta> GetContentVersionsEligibleForCleanup(DateTime olderThan, int? maxCount);
 
     /// <summary>
     ///     Gets cleanup policy override settings per content type.
diff --git a/src/Umbraco.Core/Persistence/Repositories/IDomainRepository.cs b/src/Umbraco.Core/Persistence/Repositories/IDomainRepository.cs
index 4922bbc65887..ca2346f26ca1 100644
--- a/src/Umbraco.Core/Persistence/Repositories/IDomainRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/IDomainRepository.cs
@@ -5,34 +5,34 @@ namespace Umbraco.Cms.Core.Persistence.Repositories;
 /// <summary>
 ///     Represents a repository for <see cref="IDomain" /> entities.
 /// </summary>
-public interface IDomainRepository : IReadWriteQueryRepository<int, IDomain>
+public interface IDomainRepository : IAsyncReadWriteRepository<Guid, IDomain>
 {
     /// <summary>
     ///     Gets a domain by its name.
     /// </summary>
     /// <param name="domainName">The name of the domain.</param>
     /// <returns>The domain if found; otherwise, <c>null</c>.</returns>
-    IDomain? GetByName(string domainName);
+    Task<IDomain?> GetByNameAsync(string domainName);
 
     /// <summary>
     ///     Checks whether a domain with the specified name exists.
     /// </summary>
     /// <param name="domainName">The name of the domain.</param>
     /// <returns><c>true</c> if a domain with the name exists; otherwise, <c>false</c>.</returns>
-    bool Exists(string domainName);
+    Task<bool> ExistsAsync(string domainName);
 
     /// <summary>
     ///     Gets all domains.
     /// </summary>
     /// <param name="includeWildcards">Whether to include wildcard domains.</param>
     /// <returns>A collection of domains.</returns>
-    IEnumerable<IDomain> GetAll(bool includeWildcards);
+    Task<IEnumerable<IDomain>> GetAllAsync(bool includeWildcards);
 
     /// <summary>
     ///     Gets all domains assigned to a content item.
     /// </summary>
-    /// <param name="contentId">The identifier of the content item.</param>
+    /// <param name="contentKey">The key of the content item.</param>
     /// <param name="includeWildcards">Whether to include wildcard domains.</param>
     /// <returns>A collection of domains assigned to the content.</returns>
-    IEnumerable<IDomain> GetAssignedDomains(int contentId, bool includeWildcards);
+    Task<IEnumerable<IDomain>> GetAssignedDomainsAsync(Guid contentKey, bool includeWildcards);
 }
diff --git a/src/Umbraco.Core/PropertyEditors/ElementPickerConfiguration.cs b/src/Umbraco.Core/PropertyEditors/ElementPickerConfiguration.cs
new file mode 100644
index 000000000000..18fbe23c116b
--- /dev/null
+++ b/src/Umbraco.Core/PropertyEditors/ElementPickerConfiguration.cs
@@ -0,0 +1,11 @@
+namespace Umbraco.Cms.Core.PropertyEditors;
+
+/// <summary>
+/// Represents the configuration for the element picker property editor.
+/// </summary>
+public class ElementPickerConfiguration : IIgnoreUserStartNodesConfig
+{
+    /// <inheritdoc />
+    [ConfigurationField(Constants.DataTypes.ReservedPreValueKeys.IgnoreUserStartNodes)]
+    public bool IgnoreUserStartNodes { get; set; }
+}
diff --git a/src/Umbraco.Core/PropertyEditors/ElementPickerConfigurationEditor.cs b/src/Umbraco.Core/PropertyEditors/ElementPickerConfigurationEditor.cs
new file mode 100644
index 000000000000..74b43a770e4a
--- /dev/null
+++ b/src/Umbraco.Core/PropertyEditors/ElementPickerConfigurationEditor.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using Umbraco.Cms.Core.IO;
+
+namespace Umbraco.Cms.Core.PropertyEditors;
+
+/// <summary>
+/// Represents the configuration editor for the element picker property editor.
+/// </summary>
+internal sealed class ElementPickerConfigurationEditor : ConfigurationEditor<ElementPickerConfiguration>
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ElementPickerConfigurationEditor"/> class.
+    /// </summary>
+    /// <param name="ioHelper">The IO helper.</param>
+    public ElementPickerConfigurationEditor(IIOHelper ioHelper)
+        : base(ioHelper)
+    {
+    }
+}
diff --git a/src/Umbraco.Core/PropertyEditors/ElementPickerPropertyEditor.cs b/src/Umbraco.Core/PropertyEditors/ElementPickerPropertyEditor.cs
index 6874c801d7f2..7aa3a72dca96 100644
--- a/src/Umbraco.Core/PropertyEditors/ElementPickerPropertyEditor.cs
+++ b/src/Umbraco.Core/PropertyEditors/ElementPickerPropertyEditor.cs
@@ -15,9 +15,18 @@ namespace Umbraco.Cms.Core.PropertyEditors;
     ValueEditorIsReusable = true)]
 public class ElementPickerPropertyEditor : DataEditor
 {
-    public ElementPickerPropertyEditor(IDataValueEditorFactory dataValueEditorFactory)
+    private readonly IIOHelper _ioHelper;
+
+    public ElementPickerPropertyEditor(IDataValueEditorFactory dataValueEditorFactory, IIOHelper ioHelper)
         : base(dataValueEditorFactory)
-        => SupportsReadOnly = true;
+    {
+        _ioHelper = ioHelper;
+        SupportsReadOnly = true;
+    }
+
+    /// <inheritdoc />
+    protected override IConfigurationEditor CreateConfigurationEditor() =>
+        new ElementPickerConfigurationEditor(_ioHelper);
 
     protected override IDataValueEditor CreateValueEditor() =>
         DataValueEditorFactory.Create<ElementPickerPropertyValueEditor>(Attribute!);
diff --git a/src/Umbraco.Core/PropertyEditors/RichTextConfiguration.cs b/src/Umbraco.Core/PropertyEditors/RichTextConfiguration.cs
index 13dcad145d15..3c275b5de147 100644
--- a/src/Umbraco.Core/PropertyEditors/RichTextConfiguration.cs
+++ b/src/Umbraco.Core/PropertyEditors/RichTextConfiguration.cs
@@ -11,6 +11,12 @@ public class RichTextConfiguration : IIgnoreUserStartNodesConfig
     [ConfigurationField("blocks")]
     public RichTextBlockConfiguration[]? Blocks { get; set; } = Array.Empty<RichTextBlockConfiguration>();
 
+    /// <summary>
+    /// Gets or sets the allowed media types for the media picker (comma-separated media type unique IDs).
+    /// </summary>
+    [ConfigurationField("allowedMediaTypes")]
+    public string? AllowedMediaTypes { get; set; }
+
     /// <summary>
     /// Gets or sets the media parent ID for uploaded media.
     /// </summary>
diff --git a/src/Umbraco.Core/Routing/ContentFinderByUrl.cs b/src/Umbraco.Core/Routing/ContentFinderByUrl.cs
index 86d03b2c60fa..48ada5ba83d1 100644
--- a/src/Umbraco.Core/Routing/ContentFinderByUrl.cs
+++ b/src/Umbraco.Core/Routing/ContentFinderByUrl.cs
@@ -1,5 +1,11 @@
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Models.PublishedContent;
+using Umbraco.Cms.Core.PublishedCache;
+using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Web;
 
 namespace Umbraco.Cms.Core.Routing;
@@ -10,23 +16,34 @@ namespace Umbraco.Cms.Core.Routing;
 /// <remarks>
 ///     <para>Handles <c>/foo/bar</c> where <c>/foo/bar</c> is the nice URL of a document.</para>
 /// </remarks>
-[Obsolete("Scheduled for removal in Umbraco 18.")]
 public class ContentFinderByUrl : IContentFinder
 {
     private readonly ILogger<ContentFinderByUrl> _logger;
+    private readonly IPublishedContentCache _publishedContentCache;
+    private readonly IDocumentUrlService _documentUrlService;
+    private WebRoutingSettings _webRoutingSettings;
 
     /// <summary>
     ///     Initializes a new instance of the <see cref="ContentFinderByUrl" /> class.
     /// </summary>
-    public ContentFinderByUrl(ILogger<ContentFinderByUrl> logger, IUmbracoContextAccessor umbracoContextAccessor)
+    public ContentFinderByUrl(
+        ILogger<ContentFinderByUrl> logger,
+        IUmbracoContextAccessor umbracoContextAccessor,
+        IDocumentUrlService documentUrlService,
+        IPublishedContentCache publishedContentCache,
+        IOptionsMonitor<WebRoutingSettings> webRoutingSettings)
     {
-        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        UmbracoContextAccessor =
-            umbracoContextAccessor ?? throw new ArgumentNullException(nameof(umbracoContextAccessor));
+        _logger = logger;
+        _publishedContentCache = publishedContentCache;
+        _documentUrlService = documentUrlService;
+        UmbracoContextAccessor = umbracoContextAccessor;
+
+        _webRoutingSettings = webRoutingSettings.CurrentValue;
+        webRoutingSettings.OnChange(x => _webRoutingSettings = x);
     }
 
     /// <summary>
-    ///     Gets the <see cref="IUmbracoContextAccessor" />
+    ///     Gets the <see cref="IUmbracoContextAccessor" />.
     /// </summary>
     protected IUmbracoContextAccessor UmbracoContextAccessor { get; }
 
@@ -50,6 +67,14 @@ public virtual Task<bool> TryFindContent(IPublishedRequestBuilder frequest)
         }
         else
         {
+            // If we have configured strict domain matching, and a domain has not been found for the request configured on an ancestor node,
+            // do not route the content by URL.
+            if (_webRoutingSettings.UseStrictDomainMatching)
+            {
+                return Task.FromResult(false);
+            }
+
+            // Default behaviour if strict domain matching is not enabled will be to route under the to the first root node found.
             route = frequest.AbsolutePathDecoded;
         }
 
@@ -61,5 +86,49 @@ public virtual Task<bool> TryFindContent(IPublishedRequestBuilder frequest)
     ///     Tries to find an Umbraco document for a <c>PublishedRequest</c> and a route.
     /// </summary>
     /// <returns>The document node, or null.</returns>
-    protected IPublishedContent? FindContent(IPublishedRequestBuilder docreq, string route) => null;
+    protected IPublishedContent? FindContent(IPublishedRequestBuilder docreq, string route)
+    {
+        if (!UmbracoContextAccessor.TryGetUmbracoContext(out IUmbracoContext? umbracoContext))
+        {
+            return null;
+        }
+
+        ArgumentNullException.ThrowIfNull(docreq);
+
+        if (_logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Test route {Route}", route);
+        }
+
+        Guid? documentKey = _documentUrlService.GetDocumentKeyByRoute(
+            docreq.Domain is null ? route : route[docreq.Domain.ContentId.ToString().Length..],
+            docreq.Culture,
+            docreq.Domain?.ContentId,
+            umbracoContext.InPreviewMode);
+
+
+        IPublishedContent? node = null;
+        if (documentKey.HasValue)
+        {
+            node = _publishedContentCache.GetById(umbracoContext.InPreviewMode, documentKey.Value);
+        }
+
+        if (node != null)
+        {
+            docreq.SetPublishedContent(node);
+            if (_logger.IsEnabled(LogLevel.Debug))
+            {
+                _logger.LogDebug("Got content, id={NodeId}", node.Id);
+            }
+        }
+        else
+        {
+            if (_logger.IsEnabled(LogLevel.Debug))
+            {
+                _logger.LogDebug("No match.");
+            }
+        }
+
+        return node;
+    }
 }
diff --git a/src/Umbraco.Core/Routing/ContentFinderByUrlAndTemplate.cs b/src/Umbraco.Core/Routing/ContentFinderByUrlAndTemplate.cs
deleted file mode 100644
index 32bbcb4f2388..000000000000
--- a/src/Umbraco.Core/Routing/ContentFinderByUrlAndTemplate.cs
+++ /dev/null
@@ -1,128 +0,0 @@
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using Umbraco.Cms.Core.Configuration.Models;
-using Umbraco.Cms.Core.Models;
-using Umbraco.Cms.Core.Models.PublishedContent;
-using Umbraco.Cms.Core.Services;
-using Umbraco.Cms.Core.Web;
-using Umbraco.Extensions;
-
-namespace Umbraco.Cms.Core.Routing;
-
-/// <summary>
-///     Provides an implementation of <see cref="IContentFinder" /> that handles page nice URLs and a template.
-/// </summary>
-/// <remarks>
-///     <para>
-///         This finder allows for an odd routing pattern similar to altTemplate, probably only use case is if there is
-///         an alternative mime type template and it should be routable by something like "/hello/world/json" where the
-///         JSON template is to be used for the "world" page
-///     </para>
-///     <para>
-///         Handles <c>/foo/bar/template</c> where <c>/foo/bar</c> is the nice URL of a document, and <c>template</c> a
-///         template alias.
-///     </para>
-///     <para>If successful, then the template of the document request is also assigned.</para>
-/// </remarks>
-[Obsolete("Scheduled for removal in Umbraco 18")]
-public class ContentFinderByUrlAndTemplate : ContentFinderByUrl
-{
-    private readonly IContentTypeService _contentTypeService;
-    private readonly IFileService _fileService;
-    private readonly ILogger<ContentFinderByUrlAndTemplate> _logger;
-    private WebRoutingSettings _webRoutingSettings;
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ContentFinderByUrlAndTemplate" /> class.
-    /// </summary>
-    public ContentFinderByUrlAndTemplate(
-        ILogger<ContentFinderByUrlAndTemplate> logger,
-        IFileService fileService,
-        IContentTypeService contentTypeService,
-        IUmbracoContextAccessor umbracoContextAccessor,
-        IOptionsMonitor<WebRoutingSettings> webRoutingSettings)
-        : base(logger, umbracoContextAccessor)
-    {
-        _logger = logger;
-        _fileService = fileService;
-        _contentTypeService = contentTypeService;
-        _webRoutingSettings = webRoutingSettings.CurrentValue;
-        webRoutingSettings.OnChange(x => _webRoutingSettings = x);
-    }
-
-    /// <summary>
-    ///     Tries to find and assign an Umbraco document to a <c>PublishedRequest</c>.
-    /// </summary>
-    /// <param name="frequest">The <c>PublishedRequest</c>.</param>
-    /// <returns>A value indicating whether an Umbraco document was found and assigned.</returns>
-    /// <remarks>If successful, also assigns the template.</remarks>
-    public override Task<bool> TryFindContent(IPublishedRequestBuilder frequest)
-    {
-        var path = frequest.AbsolutePathDecoded;
-
-        if (frequest.Domain != null)
-        {
-            path = DomainUtilities.PathRelativeToDomain(frequest.Domain.Uri, path);
-        }
-
-        // no template if "/"
-        if (path == "/")
-        {
-            if (_logger.IsEnabled(LogLevel.Debug))
-            {
-                _logger.LogDebug("No template in path '/'");
-            }
-
-            return Task.FromResult(false);
-        }
-
-        // look for template in last position
-        var pos = path.LastIndexOf('/');
-        var templateAlias = path[(pos + 1)..];
-        path = pos == 0 ? "/" : path[..pos];
-
-        ITemplate? template = _fileService.GetTemplate(templateAlias);
-
-        if (template == null)
-        {
-            if (_logger.IsEnabled(LogLevel.Debug))
-            {
-                _logger.LogDebug("Not a valid template: '{TemplateAlias}'", templateAlias);
-            }
-
-            return Task.FromResult(false);
-        }
-
-        if (_logger.IsEnabled(LogLevel.Debug))
-        {
-            _logger.LogDebug("Valid template: '{TemplateAlias}'", templateAlias);
-        }
-
-        // look for node corresponding to the rest of the route
-        var route = frequest.Domain != null ? frequest.Domain.ContentId + path : path;
-        IPublishedContent? node = FindContent(frequest, route);
-
-        if (node == null)
-        {
-            if (_logger.IsEnabled(LogLevel.Debug))
-            {
-                _logger.LogDebug("Not a valid route to node: '{Route}'", route);
-            }
-
-            return Task.FromResult(false);
-        }
-
-        // IsAllowedTemplate deals both with DisableAlternativeTemplates and ValidateAlternativeTemplates settings
-        if (!node.IsAllowedTemplate(_contentTypeService, _webRoutingSettings, template.Id))
-        {
-            _logger.LogWarning(
-                "Alternative template '{TemplateAlias}' is not allowed on node {NodeId}.", template.Alias, node.Id);
-            frequest.SetPublishedContent(null); // clear
-            return Task.FromResult(false);
-        }
-
-        // got it
-        frequest.SetTemplate(template);
-        return Task.FromResult(true);
-    }
-}
diff --git a/src/Umbraco.Core/Routing/ContentFinderByUrlNew.cs b/src/Umbraco.Core/Routing/ContentFinderByUrlNew.cs
deleted file mode 100644
index 181dbb261666..000000000000
--- a/src/Umbraco.Core/Routing/ContentFinderByUrlNew.cs
+++ /dev/null
@@ -1,134 +0,0 @@
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using Umbraco.Cms.Core.Configuration.Models;
-using Umbraco.Cms.Core.DependencyInjection;
-using Umbraco.Cms.Core.Models.PublishedContent;
-using Umbraco.Cms.Core.PublishedCache;
-using Umbraco.Cms.Core.Services;
-using Umbraco.Cms.Core.Web;
-
-namespace Umbraco.Cms.Core.Routing;
-
-/// <summary>
-///     Provides an implementation of <see cref="IContentFinder" /> that handles page nice URLs.
-/// </summary>
-/// <remarks>
-///     <para>Handles <c>/foo/bar</c> where <c>/foo/bar</c> is the nice URL of a document.</para>
-/// </remarks>
-public class ContentFinderByUrlNew : IContentFinder
-{
-    private readonly ILogger<ContentFinderByUrlNew> _logger;
-    private readonly IPublishedContentCache _publishedContentCache;
-    private readonly IDocumentUrlService _documentUrlService;
-    private WebRoutingSettings _webRoutingSettings;
-
-    /// <summary>
-    ///     Initializes a new instance of the <see cref="ContentFinderByUrl" /> class.
-    /// </summary>
-    public ContentFinderByUrlNew(
-        ILogger<ContentFinderByUrlNew> logger,
-        IUmbracoContextAccessor umbracoContextAccessor,
-        IDocumentUrlService documentUrlService,
-        IPublishedContentCache publishedContentCache,
-        IOptionsMonitor<WebRoutingSettings> webRoutingSettings)
-    {
-        _logger = logger;
-        _publishedContentCache = publishedContentCache;
-        _documentUrlService = documentUrlService;
-        UmbracoContextAccessor = umbracoContextAccessor;
-
-        _webRoutingSettings = webRoutingSettings.CurrentValue;
-        webRoutingSettings.OnChange(x => _webRoutingSettings = x);
-    }
-
-    /// <summary>
-    ///     Gets the <see cref="IUmbracoContextAccessor" />.
-    /// </summary>
-    protected IUmbracoContextAccessor UmbracoContextAccessor { get; }
-
-    /// <summary>
-    ///     Tries to find and assign an Umbraco document to a <c>PublishedRequest</c>.
-    /// </summary>
-    /// <param name="frequest">The <c>PublishedRequest</c>.</param>
-    /// <returns>A value indicating whether an Umbraco document was found and assigned.</returns>
-    public virtual Task<bool> TryFindContent(IPublishedRequestBuilder frequest)
-    {
-        if (!UmbracoContextAccessor.TryGetUmbracoContext(out IUmbracoContext? _))
-        {
-            return Task.FromResult(false);
-        }
-
-        string route;
-        if (frequest.Domain != null)
-        {
-            route = frequest.Domain.ContentId +
-                    DomainUtilities.PathRelativeToDomain(frequest.Domain.Uri, frequest.AbsolutePathDecoded);
-        }
-        else
-        {
-            // If we have configured strict domain matching, and a domain has not been found for the request configured on an ancestor node,
-            // do not route the content by URL.
-            if (_webRoutingSettings.UseStrictDomainMatching)
-            {
-                return Task.FromResult(false);
-            }
-
-            // Default behaviour if strict domain matching is not enabled will be to route under the to the first root node found.
-            route = frequest.AbsolutePathDecoded;
-        }
-
-        IPublishedContent? node = FindContent(frequest, route);
-        return Task.FromResult(node != null);
-    }
-
-    /// <summary>
-    ///     Tries to find an Umbraco document for a <c>PublishedRequest</c> and a route.
-    /// </summary>
-    /// <returns>The document node, or null.</returns>
-    protected IPublishedContent? FindContent(IPublishedRequestBuilder docreq, string route)
-    {
-        if (!UmbracoContextAccessor.TryGetUmbracoContext(out IUmbracoContext? umbracoContext))
-        {
-            return null;
-        }
-
-        ArgumentNullException.ThrowIfNull(docreq);
-
-        if (_logger.IsEnabled(LogLevel.Debug))
-        {
-            _logger.LogDebug("Test route {Route}", route);
-        }
-
-        Guid? documentKey = _documentUrlService.GetDocumentKeyByRoute(
-            docreq.Domain is null ? route : route[docreq.Domain.ContentId.ToString().Length..],
-            docreq.Culture,
-            docreq.Domain?.ContentId,
-            umbracoContext.InPreviewMode);
-
-
-        IPublishedContent? node = null;
-        if (documentKey.HasValue)
-        {
-            node = _publishedContentCache.GetById(umbracoContext.InPreviewMode, documentKey.Value);
-        }
-
-        if (node != null)
-        {
-            docreq.SetPublishedContent(node);
-            if (_logger.IsEnabled(LogLevel.Debug))
-            {
-                _logger.LogDebug("Got content, id={NodeId}", node.Id);
-            }
-        }
-        else
-        {
-            if (_logger.IsEnabled(LogLevel.Debug))
-            {
-                _logger.LogDebug("No match.");
-            }
-        }
-
-        return node;
-    }
-}
diff --git a/src/Umbraco.Core/Routing/DefaultUrlProvider.cs b/src/Umbraco.Core/Routing/DefaultUrlProvider.cs
index 55ad4fdf8f46..37258074a8f0 100644
--- a/src/Umbraco.Core/Routing/DefaultUrlProvider.cs
+++ b/src/Umbraco.Core/Routing/DefaultUrlProvider.cs
@@ -1,11 +1,10 @@
 using System.Globalization;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Umbraco.Cms.Core.Configuration.Models;
-using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.PublishedContent;
+using Umbraco.Cms.Core.PublishedCache;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Services.Navigation;
 using Umbraco.Cms.Core.Web;
@@ -14,61 +13,60 @@
 namespace Umbraco.Cms.Core.Routing;
 
 /// <summary>
-///     Provides urls.
+///     Provides URLs.
 /// </summary>
-[Obsolete("Use NewDefaultUrlProvider instead. Scheduled for removal in Umbraco 18.")]
 public class DefaultUrlProvider : IUrlProvider
 {
-    private readonly ILocalizationService _localizationService;
+    private readonly IPublishedContentCache _publishedContentCache;
+    private readonly IDomainCache _domainCache;
+    private readonly IIdKeyMap _idKeyMap;
+    private readonly IDocumentUrlService _documentUrlService;
+    private readonly IDocumentNavigationQueryService _navigationQueryService;
+    private readonly IPublishedContentStatusFilteringService _publishedContentStatusFilteringService;
     private readonly ILogger<DefaultUrlProvider> _logger;
     private readonly ISiteDomainMapper _siteDomainMapper;
     private readonly IUmbracoContextAccessor _umbracoContextAccessor;
-    private readonly IDocumentNavigationQueryService _navigationQueryService;
-    private readonly IPublishedContentStatusFilteringService _publishedContentStatusFilteringService;
-    private readonly IPublishedUrlProvider _publishedUrlProvider;
     private readonly UriUtility _uriUtility;
     private RequestHandlerSettings _requestSettings;
+    private readonly ILanguageService _languageService;
+
+    // TODO See if we can make GetUrlFromRoute asynchronous and avoid the GetAwaiter().GetResult() in when using ILanguageService.
 
     /// <summary>
-    ///     Initializes a new instance of the <see cref="DefaultUrlProvider"/> class.
+    /// Initializes a new instance of the <see cref="DefaultUrlProvider"/> class.
     /// </summary>
-    /// <param name="requestSettings">The request handler settings.</param>
-    /// <param name="logger">The logger.</param>
-    /// <param name="siteDomainMapper">The site domain mapper.</param>
-    /// <param name="umbracoContextAccessor">The Umbraco context accessor.</param>
-    /// <param name="uriUtility">The URI utility.</param>
-    /// <param name="localizationService">The localization service.</param>
-    /// <param name="navigationQueryService">The document navigation query service.</param>
-    /// <param name="publishedContentStatusFilteringService">The published content status filtering service.</param>
-    /// <param name="publishedUrlProvider">The published URL provider.</param>
     public DefaultUrlProvider(
         IOptionsMonitor<RequestHandlerSettings> requestSettings,
         ILogger<DefaultUrlProvider> logger,
         ISiteDomainMapper siteDomainMapper,
         IUmbracoContextAccessor umbracoContextAccessor,
         UriUtility uriUtility,
-        ILocalizationService localizationService,
+        IPublishedContentCache publishedContentCache,
+        IDomainCache domainCache,
+        IIdKeyMap idKeyMap,
+        IDocumentUrlService documentUrlService,
         IDocumentNavigationQueryService navigationQueryService,
         IPublishedContentStatusFilteringService publishedContentStatusFilteringService,
-        IPublishedUrlProvider publishedUrlProvider)
+        ILanguageService languageService)
     {
         _requestSettings = requestSettings.CurrentValue;
         _logger = logger;
         _siteDomainMapper = siteDomainMapper;
         _umbracoContextAccessor = umbracoContextAccessor;
         _uriUtility = uriUtility;
-        _localizationService = localizationService;
+        _publishedContentCache = publishedContentCache;
+        _domainCache = domainCache;
+        _idKeyMap = idKeyMap;
+        _documentUrlService = documentUrlService;
         _navigationQueryService = navigationQueryService;
         _publishedContentStatusFilteringService = publishedContentStatusFilteringService;
-        _publishedUrlProvider = publishedUrlProvider;
+        _languageService = languageService;
 
         requestSettings.OnChange(x => _requestSettings = x);
     }
 
     /// <inheritdoc />
-    public string Alias => $"{Constants.UrlProviders.Content}Legacy";
-
-    #region GetOtherUrls
+    public string Alias => Constants.UrlProviders.Content;
 
     /// <summary>
     ///     Gets the other URLs of a published content.
@@ -84,8 +82,16 @@ public DefaultUrlProvider(
     /// </remarks>
     public virtual IEnumerable<UrlInfo> GetOtherUrls(int id, Uri current)
     {
-        IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext();
-        IPublishedContent? node = umbracoContext.Content?.GetById(id);
+        Attempt<Guid> keyAttempt = _idKeyMap.GetKeyForId(id, UmbracoObjectTypes.Document);
+
+        if (keyAttempt.Success is false)
+        {
+            yield break;
+        }
+
+        Guid key = keyAttempt.Result;
+
+        IPublishedContent? node = _publishedContentCache.GetById(key);
         if (node == null)
         {
             yield break;
@@ -94,7 +100,7 @@ public virtual IEnumerable<UrlInfo> GetOtherUrls(int id, Uri current)
         // look for domains, walking up the tree
         IPublishedContent? n = node;
         IEnumerable<DomainAndUri>? domainUris =
-            DomainUtilities.DomainsForNode(umbracoContext.Domains, _siteDomainMapper, n.Id, current, false);
+            DomainUtilities.DomainsForNode(_domainCache, _siteDomainMapper, n.Id, current, false);
 
         // n is null at root
         while (domainUris == null && n != null)
@@ -102,7 +108,7 @@ public virtual IEnumerable<UrlInfo> GetOtherUrls(int id, Uri current)
             n = n.Parent<IPublishedContent>(_navigationQueryService, _publishedContentStatusFilteringService); // move to parent node
             domainUris = n == null
                 ? null
-                : DomainUtilities.DomainsForNode(umbracoContext.Domains, _siteDomainMapper, n.Id, current);
+                : DomainUtilities.DomainsForNode(_domainCache, _siteDomainMapper, n.Id, current);
         }
 
         // no domains = exit
@@ -116,14 +122,14 @@ public virtual IEnumerable<UrlInfo> GetOtherUrls(int id, Uri current)
             var culture = d.Culture;
 
             // although we are passing in culture here, if any node in this path is invariant, it ignores the culture anyways so this is ok
-            var route = _publishedUrlProvider.GetUrl(d.Id, UrlMode.Default, culture, current);
-            if (route == null)
+            var route = GetLegacyRouteFormatById(key, culture);
+            if (route == null || route == "#")
             {
                 continue;
             }
 
             // need to strip off the leading ID for the route if it exists (occurs if the route is for a node with a domain assigned)
-            var pos = route.IndexOf('/');
+            var pos = route.IndexOf('/', StringComparison.Ordinal);
             var path = pos == 0 ? route : route[pos..];
 
             var uri = new Uri(CombinePaths(d.Uri.GetLeftPart(UriPartial.Path), path));
@@ -132,9 +138,35 @@ public virtual IEnumerable<UrlInfo> GetOtherUrls(int id, Uri current)
         }
     }
 
+    #region GetPreviewUrl
+
+    /// <inheritdoc />
+    public Task<UrlInfo?> GetPreviewUrlAsync(IContent content, string? culture, string? segment)
+        => Task.FromResult<UrlInfo?>(
+            UrlInfo.AsUrl(
+                $"preview?id={content.Key}&culture={culture}&segment={segment}",
+                Alias,
+                culture,
+                isExternal: false));
+
     #endregion
 
-    #region GetUrl
+    /// <summary>
+    /// Gets the legacy route format by id
+    /// </summary>
+    /// <param name="key"></param>
+    /// <param name="culture"></param>
+    /// <returns></returns>
+    /// <remarks>
+    /// When no domain is set the route can be something like /child/grandchild
+    /// When a domain is set, the route can be something like 1234/grandchild
+    /// </remarks>
+
+    private string GetLegacyRouteFormatById(Guid key, string? culture)
+    {
+        var isDraft = _umbracoContextAccessor.GetRequiredUmbracoContext().InPreviewMode;
+        return _documentUrlService.GetLegacyRouteFormat(key, culture, isDraft);
+    }
 
     /// <inheritdoc />
     public virtual UrlInfo? GetUrl(IPublishedContent content, UrlMode mode, string? culture, Uri current)
@@ -144,35 +176,39 @@ public virtual IEnumerable<UrlInfo> GetOtherUrls(int id, Uri current)
             throw new ArgumentException("Current URL must be absolute.", nameof(current));
         }
 
-        IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext();
+        // This might seem to be some code duplication, as we do the same check in GetLegacyRouteFormat
+        // but this is strictly neccesary, as if we're coming from a published notification
+        // this document will still not always be in the memory cache. And thus we have to hit the DB
+        // We have the published content now, so we can check if the culture is published, and thus avoid the DB hit.
+        string route;
+        var isDraft = _umbracoContextAccessor.GetRequiredUmbracoContext().InPreviewMode;
+        if (isDraft is false && string.IsNullOrWhiteSpace(culture) is false && content.Cultures.Any() && content.IsInvariantOrHasCulture(culture) is false)
+        {
+            route = "#";
+        }
+        else
+        {
+            route = GetLegacyRouteFormatById(content.Key, culture);
+        }
 
         // will not use cache if previewing
-        var route = _publishedUrlProvider.GetUrl(content.Id, mode, culture, current);
 
-        return GetUrlFromRoute(route, umbracoContext, content.Id, current, mode, culture);
+        return GetUrlFromRoute(route, content.Id, current, mode, culture);
     }
 
     /// <summary>
-    ///     Gets a URL info from a route string.
+    /// Gets the URL from the provided route.
     /// </summary>
-    /// <param name="route">The route string.</param>
-    /// <param name="umbracoContext">The Umbraco context.</param>
-    /// <param name="id">The content ID.</param>
-    /// <param name="current">The current URI.</param>
-    /// <param name="mode">The URL mode.</param>
-    /// <param name="culture">The culture.</param>
-    /// <returns>The URL info, or null if the route could not be resolved.</returns>
     internal UrlInfo? GetUrlFromRoute(
         string? route,
-        IUmbracoContext umbracoContext,
         int id,
         Uri current,
         UrlMode mode,
         string? culture)
     {
-        if (string.IsNullOrWhiteSpace(route))
+        if (string.IsNullOrWhiteSpace(route) || route.Equals("#"))
         {
-            if (_logger.IsEnabled(Microsoft.Extensions.Logging.LogLevel.Debug))
+            if (_logger.IsEnabled(LogLevel.Debug))
             {
                 _logger.LogDebug(
                 "Couldn't find any page with nodeId={NodeId}. This is most likely caused by the page not being published.",
@@ -181,21 +217,31 @@ public virtual IEnumerable<UrlInfo> GetOtherUrls(int id, Uri current)
             return null;
         }
 
-        // extract domainUri and path
-        // route is /<path> or <domainRootId>/<path>
-        var pos = route.IndexOf('/');
+        // A route of just "<domainRootId>" (no slash) can occur when the path is "/" and was trimmed.
+        // Normalize by appending "/" so the existing parsing logic handles it correctly.
+        var pos = route.IndexOf('/', StringComparison.Ordinal);
+        if (pos < 0)
+        {
+            route += "/";
+            pos = route.Length - 1;
+        }
+
         var path = pos == 0 ? route : route[pos..];
-        DomainAndUri? domainUri = pos == 0
-            ? null
-            : DomainUtilities.DomainForNode(
-                umbracoContext.Domains,
+
+        DomainAndUri? domainUri = null;
+        if (pos > 0 && int.TryParse(route[..pos], NumberStyles.None, CultureInfo.InvariantCulture, out var nodeId))
+        {
+            domainUri = DomainUtilities.DomainForNode(
+                _domainCache,
                 _siteDomainMapper,
-                int.Parse(route[..pos], CultureInfo.InvariantCulture),
+                nodeId,
                 current,
                 culture);
+        }
 
-        var defaultCulture = _localizationService.GetDefaultLanguageIsoCode();
-        if (domainUri is not null || string.IsNullOrEmpty(culture) ||
+        var defaultCulture = _languageService.GetDefaultIsoCodeAsync().GetAwaiter().GetResult();
+        if (domainUri is not null ||
+            string.IsNullOrEmpty(culture) ||
             culture.Equals(defaultCulture, StringComparison.InvariantCultureIgnoreCase))
         {
             Uri url = AssembleUrl(domainUri, path, current, mode);
@@ -205,18 +251,6 @@ public virtual IEnumerable<UrlInfo> GetOtherUrls(int id, Uri current)
         return null;
     }
 
-    #endregion
-
-    #region GetPreviewUrl
-
-    /// <inheritdoc />
-    public Task<UrlInfo?> GetPreviewUrlAsync(IContent content, string? culture, string? segment)
-        => Task.FromResult<UrlInfo?>(null);
-
-    #endregion
-
-    #region Utilities
-
     private Uri AssembleUrl(DomainAndUri? domainUri, string path, Uri current, UrlMode mode)
     {
         Uri uri;
@@ -284,6 +318,4 @@ private string CombinePaths(string path1, string path2)
         var path = path1.TrimEnd(Constants.CharArrays.ForwardSlash) + path2;
         return path == "/" ? path : path.TrimEnd(Constants.CharArrays.ForwardSlash);
     }
-
-    #endregion
 }
diff --git a/src/Umbraco.Core/Routing/NewDefaultUrlProvider.cs b/src/Umbraco.Core/Routing/NewDefaultUrlProvider.cs
deleted file mode 100644
index e6d4def79ea6..000000000000
--- a/src/Umbraco.Core/Routing/NewDefaultUrlProvider.cs
+++ /dev/null
@@ -1,312 +0,0 @@
-using System.Globalization;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
-using Umbraco.Cms.Core.Configuration.Models;
-using Umbraco.Cms.Core.Models;
-using Umbraco.Cms.Core.Models.PublishedContent;
-using Umbraco.Cms.Core.PublishedCache;
-using Umbraco.Cms.Core.Services;
-using Umbraco.Cms.Core.Services.Navigation;
-using Umbraco.Cms.Core.Web;
-using Umbraco.Extensions;
-
-namespace Umbraco.Cms.Core.Routing;
-
-/// <summary>
-///     Provides URLs.
-/// </summary>
-public class NewDefaultUrlProvider : IUrlProvider
-{
-    private readonly IPublishedContentCache _publishedContentCache;
-    private readonly IDomainCache _domainCache;
-    private readonly IIdKeyMap _idKeyMap;
-    private readonly IDocumentUrlService _documentUrlService;
-    private readonly IDocumentNavigationQueryService _navigationQueryService;
-    private readonly IPublishedContentStatusFilteringService _publishedContentStatusFilteringService;
-    private readonly ILogger<NewDefaultUrlProvider> _logger;
-    private readonly ISiteDomainMapper _siteDomainMapper;
-    private readonly IUmbracoContextAccessor _umbracoContextAccessor;
-    private readonly UriUtility _uriUtility;
-    private RequestHandlerSettings _requestSettings;
-    private readonly ILanguageService _languageService;
-
-    // TODO See if we can make GetUrlFromRoute asynchronous and avoid the GetAwaiter().GetResult() in when using ILanguageService.
-
-    /// <summary>
-    /// Initializes a new instance of the <see cref="NewDefaultUrlProvider"/> class.
-    /// </summary>
-    public NewDefaultUrlProvider(
-        IOptionsMonitor<RequestHandlerSettings> requestSettings,
-        ILogger<NewDefaultUrlProvider> logger,
-        ISiteDomainMapper siteDomainMapper,
-        IUmbracoContextAccessor umbracoContextAccessor,
-        UriUtility uriUtility,
-        IPublishedContentCache publishedContentCache,
-        IDomainCache domainCache,
-        IIdKeyMap idKeyMap,
-        IDocumentUrlService documentUrlService,
-        IDocumentNavigationQueryService navigationQueryService,
-        IPublishedContentStatusFilteringService publishedContentStatusFilteringService,
-        ILanguageService languageService)
-    {
-        _requestSettings = requestSettings.CurrentValue;
-        _logger = logger;
-        _siteDomainMapper = siteDomainMapper;
-        _umbracoContextAccessor = umbracoContextAccessor;
-        _uriUtility = uriUtility;
-        _publishedContentCache = publishedContentCache;
-        _domainCache = domainCache;
-        _idKeyMap = idKeyMap;
-        _documentUrlService = documentUrlService;
-        _navigationQueryService = navigationQueryService;
-        _publishedContentStatusFilteringService = publishedContentStatusFilteringService;
-        _languageService = languageService;
-
-        requestSettings.OnChange(x => _requestSettings = x);
-    }
-
-    /// <inheritdoc />
-    public string Alias => Constants.UrlProviders.Content;
-
-    /// <summary>
-    ///     Gets the other URLs of a published content.
-    /// </summary>
-    /// <param name="id">The published content id.</param>
-    /// <param name="current">The current absolute URL.</param>
-    /// <returns>The other URLs for the published content.</returns>
-    /// <remarks>
-    ///     <para>
-    ///         Other URLs are those that <c>GetUrl</c> would not return in the current context, but would be valid
-    ///         URLs for the node in other contexts (different domain for current request, umbracoUrlAlias...).
-    ///     </para>
-    /// </remarks>
-    public virtual IEnumerable<UrlInfo> GetOtherUrls(int id, Uri current)
-    {
-        Attempt<Guid> keyAttempt = _idKeyMap.GetKeyForId(id, UmbracoObjectTypes.Document);
-
-        if (keyAttempt.Success is false)
-        {
-            yield break;
-        }
-
-        Guid key = keyAttempt.Result;
-
-        IPublishedContent? node = _publishedContentCache.GetById(key);
-        if (node == null)
-        {
-            yield break;
-        }
-
-        // look for domains, walking up the tree
-        IPublishedContent? n = node;
-        IEnumerable<DomainAndUri>? domainUris =
-            DomainUtilities.DomainsForNode(_domainCache, _siteDomainMapper, n.Id, current, false);
-
-        // n is null at root
-        while (domainUris == null && n != null)
-        {
-            n = n.Parent<IPublishedContent>(_navigationQueryService, _publishedContentStatusFilteringService); // move to parent node
-            domainUris = n == null
-                ? null
-                : DomainUtilities.DomainsForNode(_domainCache, _siteDomainMapper, n.Id, current);
-        }
-
-        // no domains = exit
-        if (domainUris == null)
-        {
-            yield break;
-        }
-
-        foreach (DomainAndUri d in domainUris)
-        {
-            var culture = d.Culture;
-
-            // although we are passing in culture here, if any node in this path is invariant, it ignores the culture anyways so this is ok
-            var route = GetLegacyRouteFormatById(key, culture);
-            if (route == null || route == "#")
-            {
-                continue;
-            }
-
-            // need to strip off the leading ID for the route if it exists (occurs if the route is for a node with a domain assigned)
-            var pos = route.IndexOf('/', StringComparison.Ordinal);
-            var path = pos == 0 ? route : route[pos..];
-
-            var uri = new Uri(CombinePaths(d.Uri.GetLeftPart(UriPartial.Path), path));
-            uri = _uriUtility.UriFromUmbraco(uri, _requestSettings);
-            yield return UrlInfo.FromUri(uri, Alias, culture);
-        }
-    }
-
-    #region GetPreviewUrl
-
-    /// <inheritdoc />
-    public Task<UrlInfo?> GetPreviewUrlAsync(IContent content, string? culture, string? segment)
-        => Task.FromResult<UrlInfo?>(
-            UrlInfo.AsUrl(
-                $"preview?id={content.Key}&culture={culture}&segment={segment}",
-                Alias,
-                culture,
-                isExternal: false));
-
-    #endregion
-
-    /// <summary>
-    /// Gets the legacy route format by id
-    /// </summary>
-    /// <param name="key"></param>
-    /// <param name="culture"></param>
-    /// <returns></returns>
-    /// <remarks>
-    /// When no domain is set the route can be something like /child/grandchild
-    /// When a domain is set, the route can be something like 1234/grandchild
-    /// </remarks>
-
-    private string GetLegacyRouteFormatById(Guid key, string? culture)
-    {
-        var isDraft = _umbracoContextAccessor.GetRequiredUmbracoContext().InPreviewMode;
-        return _documentUrlService.GetLegacyRouteFormat(key, culture, isDraft);
-    }
-
-    /// <inheritdoc />
-    public virtual UrlInfo? GetUrl(IPublishedContent content, UrlMode mode, string? culture, Uri current)
-    {
-        if (!current.IsAbsoluteUri)
-        {
-            throw new ArgumentException("Current URL must be absolute.", nameof(current));
-        }
-
-        // This might seem to be some code duplication, as we do the same check in GetLegacyRouteFormat
-        // but this is strictly neccesary, as if we're coming from a published notification
-        // this document will still not always be in the memory cache. And thus we have to hit the DB
-        // We have the published content now, so we can check if the culture is published, and thus avoid the DB hit.
-        string route;
-        var isDraft = _umbracoContextAccessor.GetRequiredUmbracoContext().InPreviewMode;
-        if (isDraft is false && string.IsNullOrWhiteSpace(culture) is false && content.Cultures.Any() && content.IsInvariantOrHasCulture(culture) is false)
-        {
-            route = "#";
-        }
-        else
-        {
-            route = GetLegacyRouteFormatById(content.Key, culture);
-        }
-
-        // will not use cache if previewing
-
-        return GetUrlFromRoute(route, content.Id, current, mode, culture);
-    }
-
-    /// <summary>
-    /// Gets the URL from the provided route.
-    /// </summary>
-    internal UrlInfo? GetUrlFromRoute(
-        string? route,
-        int id,
-        Uri current,
-        UrlMode mode,
-        string? culture)
-    {
-        if (string.IsNullOrWhiteSpace(route) || route.Equals("#"))
-        {
-            if (_logger.IsEnabled(LogLevel.Debug))
-            {
-                _logger.LogDebug(
-                "Couldn't find any page with nodeId={NodeId}. This is most likely caused by the page not being published.",
-                id);
-            }
-            return null;
-        }
-
-        // extract domainUri and path
-        // route is /<path> or <domainRootId>/<path>
-        var pos = route.IndexOf('/', StringComparison.Ordinal);
-        var path = pos == 0 ? route : route[pos..];
-        DomainAndUri? domainUri = pos == 0
-            ? null
-            : DomainUtilities.DomainForNode(
-                _domainCache,
-                _siteDomainMapper,
-                int.Parse(route[..pos], CultureInfo.InvariantCulture),
-                current,
-                culture);
-
-        var defaultCulture = _languageService.GetDefaultIsoCodeAsync().GetAwaiter().GetResult();
-        if (domainUri is not null ||
-            string.IsNullOrEmpty(culture) ||
-            culture.Equals(defaultCulture, StringComparison.InvariantCultureIgnoreCase))
-        {
-            Uri url = AssembleUrl(domainUri, path, current, mode);
-            return UrlInfo.FromUri(url, Alias, culture);
-        }
-
-        return null;
-    }
-
-    private Uri AssembleUrl(DomainAndUri? domainUri, string path, Uri current, UrlMode mode)
-    {
-        Uri uri;
-
-        // ignore vdir at that point, UriFromUmbraco will do it
-        // no domain was found
-        if (domainUri == null)
-        {
-            if (current == null)
-            {
-                mode = UrlMode.Relative; // best we can do
-            }
-
-            switch (mode)
-            {
-                case UrlMode.Absolute:
-                    uri = new Uri(current!.GetLeftPart(UriPartial.Authority) + path);
-                    break;
-                case UrlMode.Relative:
-                case UrlMode.Auto:
-                    uri = new Uri(path, UriKind.Relative);
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(mode));
-            }
-        }
-
-        // a domain was found
-        else
-        {
-            if (mode == UrlMode.Auto)
-            {
-                // this check is a little tricky, we can't just compare domains
-                if (current != null && domainUri.Uri.GetLeftPart(UriPartial.Authority) ==
-                    current.GetLeftPart(UriPartial.Authority))
-                {
-                    mode = UrlMode.Relative;
-                }
-                else
-                {
-                    mode = UrlMode.Absolute;
-                }
-            }
-
-            switch (mode)
-            {
-                case UrlMode.Absolute:
-                    uri = new Uri(CombinePaths(domainUri.Uri.GetLeftPart(UriPartial.Path), path));
-                    break;
-                case UrlMode.Relative:
-                    uri = new Uri(CombinePaths(domainUri.Uri.AbsolutePath, path), UriKind.Relative);
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(mode));
-            }
-        }
-
-        // UriFromUmbraco will handle vdir
-        // meaning it will add vdir into domain URLs too!
-        return _uriUtility.UriFromUmbraco(uri, _requestSettings);
-    }
-
-    private string CombinePaths(string path1, string path2)
-    {
-        var path = path1.TrimEnd(Constants.CharArrays.ForwardSlash) + path2;
-        return path == "/" ? path : path.TrimEnd(Constants.CharArrays.ForwardSlash);
-    }
-}
diff --git a/src/Umbraco.Core/Routing/UrlProvider.cs b/src/Umbraco.Core/Routing/UrlProvider.cs
index c52947e4312a..8ec810c5a8a7 100644
--- a/src/Umbraco.Core/Routing/UrlProvider.cs
+++ b/src/Umbraco.Core/Routing/UrlProvider.cs
@@ -151,7 +151,7 @@ public string GetUrl(IPublishedContent? content, UrlMode mode = UrlMode.Default,
         public string GetUrlFromRoute(int id, string? route, string? culture)
         {
             IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext();
-            NewDefaultUrlProvider? provider = _urlProviders.OfType<NewDefaultUrlProvider>().FirstOrDefault();
+            DefaultUrlProvider? provider = _urlProviders.OfType<DefaultUrlProvider>().FirstOrDefault();
             var url = provider == null
                 ? route // what else?
                 : provider.GetUrlFromRoute(route, id, umbracoContext.CleanedUmbracoUrl, Mode, culture)?.Url?.ToString();
diff --git a/src/Umbraco.Core/Security/ContentPermissions.cs b/src/Umbraco.Core/Security/ContentPermissions.cs
index 69c91a98e450..7fe79b5c9bf4 100644
--- a/src/Umbraco.Core/Security/ContentPermissions.cs
+++ b/src/Umbraco.Core/Security/ContentPermissions.cs
@@ -97,91 +97,7 @@ public static bool HasPathAccess(string? path, int[]? startNodeIds, int recycleB
         return startNodeIds.Any(x =>
             formattedPath.Contains(string.Concat(",", x.ToString(CultureInfo.InvariantCulture), ",")));
     }
-
-    /// <summary>
-    ///     Checks if the user has access to the specified node and permissions set
-    /// </summary>
-    /// <param name="nodeId"></param>
-    /// <param name="user"></param>
-    /// <param name="contentItem">The <see cref="IContent" /> item resolved if one was found for the id</param>
-    /// <param name="permissionsToCheck"></param>
-    /// <returns></returns>
-    [Obsolete($"Please use {nameof(IContentPermissionService)} instead. Scheduled for removal in Umbraco 18.")]
-    public ContentAccess CheckPermissions(
-        int nodeId,
-        IUser? user,
-        out IContent? contentItem,
-        IReadOnlySet<string>? permissionsToCheck = null)
-    {
-        if (user == null)
-        {
-            throw new ArgumentNullException(nameof(user));
-        }
-
-        bool hasPathAccess;
-        contentItem = null;
-
-        if (nodeId == Constants.System.Root)
-        {
-            hasPathAccess = user.HasContentRootAccess(_entityService, _appCaches);
-        }
-        else if (nodeId == Constants.System.RecycleBinContent)
-        {
-            hasPathAccess = user.HasContentBinAccess(_entityService, _appCaches);
-        }
-        else
-        {
-            contentItem = _contentService.GetById(nodeId);
-
-            if (contentItem == null)
-            {
-                return ContentAccess.NotFound;
-            }
-
-            hasPathAccess = user.HasPathAccess(contentItem, _entityService, _appCaches);
-        }
-
-        if (hasPathAccess == false)
-        {
-            return ContentAccess.Denied;
-        }
-
-        if (permissionsToCheck == null || permissionsToCheck.Count == 0)
-        {
-            return ContentAccess.Granted;
-        }
-
-        // get the implicit/inherited permissions for the user for this path
-        // if there is no content item for this id, then just use the id as the path (i.e. -1 or -20)
-        return CheckPermissionsPath(contentItem?.Path ?? nodeId.ToString(CultureInfo.InvariantCulture), user, permissionsToCheck)
-            ? ContentAccess.Granted
-            : ContentAccess.Denied;
-    }
-
-    [Obsolete($"Please use {nameof(IContentPermissionService)} instead. Scheduled for removal in Umbraco 18.")]
-    private bool CheckPermissionsPath(string? path, IUser user, IReadOnlySet<string>? permissionsToCheck = null)
-    {
-        if (permissionsToCheck == null)
-        {
-            permissionsToCheck = new HashSet<string>();
-        }
-
-        // get the implicit/inherited permissions for the user for this path
-        EntityPermissionSet permission = _userService.GetPermissionsForPath(user, path);
-
-        var allowed = true;
-        foreach (var p in permissionsToCheck)
-        {
-            if (permission == null
-                || permission.GetAllPermissions().Contains(p.ToString(CultureInfo.InvariantCulture)) == false)
-            {
-                allowed = false;
-            }
-        }
-
-        return allowed;
-    }
-
+    
     /// <summary>
     ///     Determines if a path is within the branch of the user's start node.
     /// </summary>
diff --git a/src/Umbraco.Core/Services/AuditEntryService.cs b/src/Umbraco.Core/Services/AuditEntryService.cs
index b8065ea94496..caecdb2c9ecc 100644
--- a/src/Umbraco.Core/Services/AuditEntryService.cs
+++ b/src/Umbraco.Core/Services/AuditEntryService.cs
@@ -124,9 +124,9 @@ private IAuditEntry WriteInner(
         string eventType,
         string eventDetails)
     {
-        if (performingUserId < Constants.Security.SuperUserId)
+        if (performingUserKey == Guid.Empty)
         {
-            throw new ArgumentOutOfRangeException(nameof(performingUserId));
+            throw new ArgumentException(nameof(performingUserKey));
         }
 
         if (string.IsNullOrWhiteSpace(performingDetails))
diff --git a/src/Umbraco.Core/Services/Changes/ContentTypeChangeTypes.cs b/src/Umbraco.Core/Services/Changes/ContentTypeChangeTypes.cs
index 7f804b4ab0ec..dc737f85e704 100644
--- a/src/Umbraco.Core/Services/Changes/ContentTypeChangeTypes.cs
+++ b/src/Umbraco.Core/Services/Changes/ContentTypeChangeTypes.cs
@@ -3,8 +3,16 @@ namespace Umbraco.Cms.Core.Services.Changes;
 /// <summary>
 ///     Represents the types of changes that can occur on a content type.
 /// </summary>
+/// <remarks>
+///     <para>
+///         The base flags (<see cref="RefreshMain"/> and <see cref="RefreshOther"/>) represent coarse-grained
+///         structural vs non-structural change categories. The granular flags (e.g. <see cref="AliasChanged"/>,
+///         <see cref="PropertyRemoved"/>) include their parent flag via bitwise OR, so existing consumers that
+///         only check for <see cref="RefreshMain"/> or <see cref="RefreshOther"/> continue to work unchanged.
+///     </para>
+/// </remarks>
 [Flags]
-public enum ContentTypeChangeTypes : byte
+public enum ContentTypeChangeTypes : ushort
 {
     /// <summary>
     ///     No change has occurred.
@@ -50,5 +58,46 @@ public enum ContentTypeChangeTypes : byte
     ///     Content type variation setting has changed (e.g., from invariant to variant or vice versa).
     ///     This impacts how URL segments and aliases are stored (NULL languageId for invariant, specific ID for variant).
     /// </summary>
-    VariationChanged = 16,
+    VariationChanged = 16 | RefreshMain,
+
+    // Granular structural flags (always include RefreshMain)
+
+    /// <summary>
+    ///     The content type alias was changed.
+    /// </summary>
+    AliasChanged = 32 | RefreshMain,
+
+    /// <summary>
+    ///     One or more property type aliases were changed.
+    ///     This effectively corresponds to removing and re-adding a property type.
+    /// </summary>
+    PropertyAliasChanged = 64 | RefreshMain,
+
+    /// <summary>
+    ///     One or more property types were removed from the content type.
+    /// </summary>
+    PropertyRemoved = 128 | RefreshMain,
+
+    /// <summary>
+    ///     One or more compositions were removed from the content type.
+    /// </summary>
+    CompositionRemoved = 256 | RefreshMain,
+
+    /// <summary>
+    ///     The variation setting of one or more property types changed
+    ///     (e.g., from invariant to variant or vice versa).
+    /// </summary>
+    PropertyVariationChanged = 512 | RefreshMain,
+
+    // Granular non-structural flags (always include RefreshOther)
+
+    /// <summary>
+    ///     One or more property types were added to the content type.
+    /// </summary>
+    PropertyAdded = 1024 | RefreshOther,
+
+    /// <summary>
+    ///     One or more compositions were added to the content type.
+    /// </summary>
+    CompositionAdded = 2048 | RefreshOther,
 }
diff --git a/src/Umbraco.Core/Services/ContentBlueprintEditingService.cs b/src/Umbraco.Core/Services/ContentBlueprintEditingService.cs
index e66338742a4c..e93fb56b3e64 100644
--- a/src/Umbraco.Core/Services/ContentBlueprintEditingService.cs
+++ b/src/Umbraco.Core/Services/ContentBlueprintEditingService.cs
@@ -235,8 +235,8 @@ public async Task<Attempt<ContentEditingOperationStatus>> MoveAsync(Guid key, Gu
         //       structural node data like path, level, sort orders etc.
         toMove.ParentId = parentId;
 
-        // Save blueprint
-        await SaveAsync(toMove, userKey);
+        var userId = await GetUserIdAsync(userKey);
+        ContentService.MoveBlueprint(toMove, userId);
 
         scope.Complete();
 
diff --git a/src/Umbraco.Core/Services/ContentPublishingServiceBase.cs b/src/Umbraco.Core/Services/ContentPublishingServiceBase.cs
index 269c7db4aad0..9e53536c533a 100644
--- a/src/Umbraco.Core/Services/ContentPublishingServiceBase.cs
+++ b/src/Umbraco.Core/Services/ContentPublishingServiceBase.cs
@@ -1,4 +1,4 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Events;
diff --git a/src/Umbraco.Core/Services/ContentService.cs b/src/Umbraco.Core/Services/ContentService.cs
index 89cededadaab..ca6e283d7944 100644
--- a/src/Umbraco.Core/Services/ContentService.cs
+++ b/src/Umbraco.Core/Services/ContentService.cs
@@ -767,44 +767,6 @@ public IDictionary<int, IEnumerable<ContentSchedule>> GetContentSchedulesByIds(G
         return intKeyedResults;
     }
 
-    /// <inheritdoc/>
-    public IDictionary<Guid, IEnumerable<ContentSchedule>> GetContentSchedulesByKeys(Guid[] keys)
-    {
-        if (keys.Length == 0)
-        {
-            return ImmutableDictionary<Guid, IEnumerable<ContentSchedule>>.Empty;
-        }
-
-        Dictionary<int, Guid> intToKeyMap = new(keys.Length);
-        foreach (Guid key in keys)
-        {
-            Attempt<int> contentId = _idKeyMap.GetIdForKey(key, UmbracoObjectTypes.Document);
-            if (contentId.Success is false)
-            {
-                continue;
-            }
-
-            intToKeyMap[contentId.Result] = key;
-        }
-
-        using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);
-        scope.ReadLock(Constants.Locks.ContentTree);
-
-        IDictionary<int, IEnumerable<ContentSchedule>> intKeyedResults =
-            _documentRepository.GetContentSchedulesByIds(intToKeyMap.Keys.ToArray());
-
-        var guidKeyedResults = new Dictionary<Guid, IEnumerable<ContentSchedule>>(intKeyedResults.Count);
-        foreach (KeyValuePair<int, IEnumerable<ContentSchedule>> entry in intKeyedResults)
-        {
-            if (intToKeyMap.TryGetValue(entry.Key, out Guid guidKey))
-            {
-                guidKeyedResults[guidKey] = entry.Value;
-            }
-        }
-
-        return guidKeyedResults;
-    }
-
     /// <summary>
     ///     Checks if the passed in <see cref="IContent" /> can be published based on the ancestors publish state.
     /// </summary>
@@ -1515,7 +1477,7 @@ public bool RecycleBinSmells()
             scope.WriteLock(Constants.Locks.ContentTree);
 
             TryGetParentKey(parentId, out Guid? parentKey);
-            if (scope.Notifications.PublishCancelable(new ContentCopyingNotification(content, copy, parentId, parentKey, eventMessages)))
+            if (scope.Notifications.PublishCancelable(new ContentCopyingNotification(content, copy, parentKey, eventMessages)))
             {
                 scope.Complete();
                 return null;
@@ -1585,7 +1547,7 @@ public bool RecycleBinSmells()
                         IContent descendantCopy = descendant.DeepCloneWithResetIdentities();
                         descendantCopy.ParentId = parentId;
 
-                        if (scope.Notifications.PublishCancelable(new ContentCopyingNotification(descendant, descendantCopy, parentId, parentKey, eventMessages)))
+                        if (scope.Notifications.PublishCancelable(new ContentCopyingNotification(descendant, descendantCopy, parentKey, eventMessages)))
                         {
                             continue;
                         }
@@ -1622,7 +1584,7 @@ public bool RecycleBinSmells()
                 new ContentTreeChangeNotification(copy, TreeChangeTypes.RefreshBranch, eventMessages));
             foreach (Tuple<IContent, IContent> x in CollectionsMarshal.AsSpan(copies))
             {
-                scope.Notifications.Publish(new ContentCopiedNotification(x.Item1, x.Item2, parentId, parentKey, relateToOriginal, eventMessages));
+                scope.Notifications.Publish(new ContentCopiedNotification(x.Item1, x.Item2, parentKey, relateToOriginal, eventMessages));
             }
 
             Audit(AuditType.Copy, userId, content.Id);
@@ -2045,6 +2007,7 @@ public void DeleteOfType(int contentTypeId, int userId = Constants.Security.Supe
     /// </summary>
     /// <param name="content">The blueprint content to save.</param>
     /// <param name="userId">The optional ID of the user saving the blueprint.</param>
+    [Obsolete("Please use the method taking all parameters. Scheduled for removal in Umbraco 20.")]
     public void SaveBlueprint(IContent content, int userId = Constants.Security.SuperUserId)
         => SaveBlueprint(content, null, userId);
 
@@ -2082,6 +2045,33 @@ public void SaveBlueprint(IContent content, IContent? createdFromContent, int us
         }
     }
 
+    /// <summary>
+    /// Moves a content blueprint to a different container.
+    /// </summary>
+    /// <param name="content">The blueprint content to move.</param>
+    /// <param name="userId">The optional ID of the user moving the blueprint.</param>
+    public void MoveBlueprint(IContent content, int userId = Constants.Security.SuperUserId)
+    {
+        EventMessages evtMsgs = EventMessagesFactory.Get();
+
+        content.Blueprint = true;
+
+        using (ICoreScope scope = ScopeProvider.CreateCoreScope())
+        {
+            scope.WriteLock(Constants.Locks.ContentTree);
+
+            content.WriterId = userId;
+
+            _documentBlueprintRepository.Save(content);
+
+            Audit(AuditType.Move, userId, content.Id);
+
+            scope.Notifications.Publish(new ContentTreeChangeNotification(content, TreeChangeTypes.RefreshNode, evtMsgs));
+
+            scope.Complete();
+        }
+    }
+
     /// <summary>
     /// Deletes a content blueprint.
     /// </summary>
diff --git a/src/Umbraco.Core/Services/ContentTypeEditing/IMediaTypeEditingService.cs b/src/Umbraco.Core/Services/ContentTypeEditing/IMediaTypeEditingService.cs
index 20fef585b6c5..ec2a8f201768 100644
--- a/src/Umbraco.Core/Services/ContentTypeEditing/IMediaTypeEditingService.cs
+++ b/src/Umbraco.Core/Services/ContentTypeEditing/IMediaTypeEditingService.cs
@@ -83,23 +83,7 @@ Task<IEnumerable<ContentTypeAvailableCompositionsResult>> GetAvailableCompositio
     ///     Unlike <c>GetMediaTypesForFileExtensionAsync</c>, this method always includes catch-all media types
     ///     (those with no extension restrictions) alongside specific extension matches.
     /// </remarks>
-    // TODO (V18): Remove the default implementation.
-    async Task<PagedModel<MediaTypeFileExtensionMatchResult>> GetMediaTypesForFileExtensionWithMatchInfoAsync(string fileExtension, int skip, int take)
-    {
-#pragma warning disable CS0618 // Type or member is obsolete
-        PagedModel<IMediaType> result = await GetMediaTypesForFileExtensionAsync(fileExtension, skip, take);
-#pragma warning restore CS0618 // Type or member is obsolete
-        return new PagedModel<MediaTypeFileExtensionMatchResult>
-        {
-            Items = result.Items
-                .Select(mt => new MediaTypeFileExtensionMatchResult
-                {
-                    MediaType = mt,
-                    IsSpecificMatch = true,
-                }),
-            Total = result.Total,
-        };
-    }
+    Task<PagedModel<MediaTypeFileExtensionMatchResult>> GetMediaTypesForFileExtensionWithMatchInfoAsync(string fileExtension, int skip, int take);
 
     /// <summary>
     ///     Gets media types that are considered folder types.
diff --git a/src/Umbraco.Core/Services/ContentTypeEditing/MediaTypeEditingService.cs b/src/Umbraco.Core/Services/ContentTypeEditing/MediaTypeEditingService.cs
index ce18b5c59757..eb9af06e0ff8 100644
--- a/src/Umbraco.Core/Services/ContentTypeEditing/MediaTypeEditingService.cs
+++ b/src/Umbraco.Core/Services/ContentTypeEditing/MediaTypeEditingService.cs
@@ -66,7 +66,7 @@ public MediaTypeEditingService(
     {
         if (mediaType.IsSystemMediaType() && mediaType.Alias != model.Alias)
         {
-            return Attempt.FailWithStatus<IMediaType?, ContentTypeOperationStatus>(ContentTypeOperationStatus.NotAllowed, null);
+            return Attempt.FailWithStatus<IMediaType?, ContentTypeOperationStatus>(ContentTypeOperationStatus.SystemAliasChangeNotAllowed, null);
         }
 
         Attempt<IMediaType?, ContentTypeOperationStatus> result = await ValidateAndMapForUpdateAsync(mediaType, model);
diff --git a/src/Umbraco.Core/Services/ContentTypeServiceBase{TRepository,TItem}.cs b/src/Umbraco.Core/Services/ContentTypeServiceBase{TRepository,TItem}.cs
index 6b2d0736587d..f3468d3ec2ee 100644
--- a/src/Umbraco.Core/Services/ContentTypeServiceBase{TRepository,TItem}.cs
+++ b/src/Umbraco.Core/Services/ContentTypeServiceBase{TRepository,TItem}.cs
@@ -400,33 +400,84 @@ internal IEnumerable<ContentTypeChange<TItem>> ComposeContentTypeChanges(params
             // property variation change?
             var hasAnyPropertyVariationChanged = contentType.WasPropertyTypeVariationChanged();
 
-            // main impact on properties?
-            var hasPropertyMainImpact = hasContentTypeVariationChanged || hasAnyPropertyVariationChanged
-                                                                       || hasAnyCompositionBeenRemoved || hasAnyPropertyBeenRemoved || hasAnyPropertyChangedAlias;
+            // Detect all granular change types independently so that structural
+            // and non-structural changes can be detected in the same operation
+            // (e.g. removing a property AND adding another at the same time).
+            var hasAnyChange = false;
+
+            // --- Structural changes (each includes RefreshMain automatically) ---
 
-            if (hasAliasChanged || hasPropertyMainImpact)
+            if (hasAliasChanged)
             {
-                // add that one, as a main change
-                AddChange(changes, contentType, ContentTypeChangeTypes.RefreshMain);
+                AddChange(changes, contentType, ContentTypeChangeTypes.AliasChanged);
+                hasAnyChange = true;
+            }
 
-                // Add VariationChanged flag if content type variation changed.
-                // This is used by DocumentUrlService to rebuild URL cache with correct languageId.
-                if (hasContentTypeVariationChanged)
-                {
-                    AddChange(changes, contentType, ContentTypeChangeTypes.VariationChanged);
-                }
+            if (hasAnyPropertyChangedAlias)
+            {
+                AddChange(changes, contentType, ContentTypeChangeTypes.PropertyAliasChanged);
+                hasAnyChange = true;
+            }
 
-                if (hasPropertyMainImpact)
+            if (hasAnyPropertyBeenRemoved)
+            {
+                AddChange(changes, contentType, ContentTypeChangeTypes.PropertyRemoved);
+                hasAnyChange = true;
+            }
+
+            if (hasAnyCompositionBeenRemoved)
+            {
+                AddChange(changes, contentType, ContentTypeChangeTypes.CompositionRemoved);
+                hasAnyChange = true;
+            }
+
+            if (hasAnyPropertyVariationChanged)
+            {
+                AddChange(changes, contentType, ContentTypeChangeTypes.PropertyVariationChanged);
+                hasAnyChange = true;
+            }
+
+            // Add VariationChanged flag if content type variation changed.
+            // This is used by DocumentUrlService to rebuild URL cache with correct languageId.
+            if (hasContentTypeVariationChanged)
+            {
+                AddChange(changes, contentType, ContentTypeChangeTypes.VariationChanged);
+                hasAnyChange = true;
+            }
+
+            // main impact on properties? Propagate RefreshMain to composed types.
+            var hasPropertyMainImpact = hasContentTypeVariationChanged || hasAnyPropertyVariationChanged
+                                                                       || hasAnyCompositionBeenRemoved || hasAnyPropertyBeenRemoved || hasAnyPropertyChangedAlias;
+            if (hasPropertyMainImpact)
+            {
+                foreach (TItem c in GetComposedOf(contentType.Id))
                 {
-                    foreach (TItem c in GetComposedOf(contentType.Id))
-                    {
-                        AddChange(changes, c, ContentTypeChangeTypes.RefreshMain);
-                    }
+                    AddChange(changes, c, ContentTypeChangeTypes.RefreshMain);
                 }
             }
-            else
+
+            // --- Non-structural changes (each includes RefreshOther automatically) ---
+
+            // new properties added?
+            var hasAnyPropertyBeenAdded = contentType.PropertyTypes.Any(pt => pt.WasPropertyDirty("Id"));
+            if (hasAnyPropertyBeenAdded)
+            {
+                AddChange(changes, contentType, ContentTypeChangeTypes.PropertyAdded);
+                hasAnyChange = true;
+            }
+
+            // compositions added?
+            var hasAnyCompositionBeenAdded = dirty.WasPropertyDirty("HasCompositionTypeBeenAdded");
+            if (hasAnyCompositionBeenAdded)
+            {
+                AddChange(changes, contentType, ContentTypeChangeTypes.CompositionAdded);
+                hasAnyChange = true;
+            }
+
+            // Fall back to bare RefreshOther if none of the specific checks matched
+            // (e.g. for changes we haven't categorized yet).
+            if (!hasAnyChange)
             {
-                // add that one, as an other change
                 AddChange(changes, contentType, ContentTypeChangeTypes.RefreshOther);
             }
         }
@@ -1054,93 +1105,6 @@ public void Delete(IEnumerable<TItem> items, int userId = Constants.Security.Sup
     #endregion
 
     #region Copy
-
-    /// <summary>
-    /// Copies the specified content type to a new content type with the specified alias and name.
-    /// </summary>
-    /// <param name="original">The original content type to copy.</param>
-    /// <param name="alias">The alias for the new content type.</param>
-    /// <param name="name">The name for the new content type.</param>
-    /// <param name="parentId">The parent identifier for the new content type. Use -1 for root.</param>
-    /// <returns>The newly created content type copy.</returns>
-    [Obsolete("Please use CopyAsync. Scheduled for removal in Umbraco 18.")]
-    public TItem Copy(TItem original, string alias, string name, int parentId = -1)
-    {
-        TItem? parent = null;
-        if (parentId > 0)
-        {
-            parent = Get(parentId);
-            if (parent == null)
-            {
-                throw new InvalidOperationException("Could not find parent with id " + parentId);
-            }
-        }
-        return Copy(original, alias, name, parent);
-    }
-
-    /// <summary>
-    /// Copies the specified content type to a new content type with the specified alias, name, and parent.
-    /// </summary>
-    /// <param name="original">The original content type to copy.</param>
-    /// <param name="alias">The alias for the new content type.</param>
-    /// <param name="name">The name for the new content type.</param>
-    /// <param name="parent">The parent content type for the new content type. Use null for root.</param>
-    /// <returns>The newly created content type copy.</returns>
-    [Obsolete("Please use CopyAsync. Scheduled for removal in Umbraco 18.")]
-    public TItem Copy(TItem original, string alias, string name, TItem? parent)
-    {
-        if (original == null)
-        {
-            throw new ArgumentNullException(nameof(original));
-        }
-
-        if (alias == null)
-        {
-            throw new ArgumentNullException(nameof(alias));
-        }
-
-        if (string.IsNullOrWhiteSpace(alias))
-        {
-            throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(alias));
-        }
-
-        if (parent != null && parent.HasIdentity == false)
-        {
-            throw new InvalidOperationException("Parent must have an identity.");
-        }
-
-        // this is illegal
-        //var originalb = (ContentTypeCompositionBase)original;
-        // but we *know* it has to be a ContentTypeCompositionBase anyways
-        var originalb = (ContentTypeCompositionBase) (object) original;
-        var clone = (TItem) (object) originalb.DeepCloneWithResetIdentities(alias);
-
-        clone.Name = name;
-
-        //remove all composition that is not it's current alias
-        var compositionAliases = clone.CompositionAliases().Except(new[] { alias }).ToList();
-        foreach (var a in CollectionsMarshal.AsSpan(compositionAliases))
-        {
-            clone.RemoveContentType(a);
-        }
-
-        //if a parent is specified set it's composition and parent
-        if (parent != null)
-        {
-            //add a new parent composition
-            clone.AddContentType(parent);
-            clone.ParentId = parent.Id;
-        }
-        else
-        {
-            //set to root
-            clone.ParentId = -1;
-        }
-
-        Save(clone);
-        return clone;
-    }
-
     /// <summary>
     /// Copies a content type to a specified container.
     /// </summary>
diff --git a/src/Umbraco.Core/Services/ContentVersionService.cs b/src/Umbraco.Core/Services/ContentVersionService.cs
index bb8439830da0..304611220a38 100644
--- a/src/Umbraco.Core/Services/ContentVersionService.cs
+++ b/src/Umbraco.Core/Services/ContentVersionService.cs
@@ -1,4 +1,6 @@
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Notifications;
@@ -17,7 +19,7 @@ internal sealed class ContentVersionService : ContentVersionServiceBase<IContent
     /// Initializes a new instance of the <see cref="ContentVersionService"/> class.
     /// </summary>
     /// <param name="logger">The logger.</param>
-    /// <param name="documentVersionRepository">The document version repository.</param>
+    /// <param name="contentVersionRepository">The content version repository.</param>
     /// <param name="contentVersionCleanupPolicy">The content version cleanup policy.</param>
     /// <param name="scopeProvider">The scope provider.</param>
     /// <param name="eventMessagesFactory">The event messages factory.</param>
@@ -26,6 +28,7 @@ internal sealed class ContentVersionService : ContentVersionServiceBase<IContent
     /// <param name="entityService">The entity service.</param>
     /// <param name="contentService">The content service.</param>
     /// <param name="userIdKeyResolver">The user ID key resolver.</param>
+    /// <param name="contentSettings">The content settings.</param>
     public ContentVersionService(
         ILogger<ContentVersionService> logger,
         IDocumentVersionRepository contentVersionRepository,
@@ -36,7 +39,8 @@ public ContentVersionService(
         ILanguageRepository languageRepository,
         IEntityService entityService,
         IContentService contentService,
-        IUserIdKeyResolver userIdKeyResolver)
+        IUserIdKeyResolver userIdKeyResolver,
+        IOptionsMonitor<ContentSettings> contentSettings)
         : base(
             logger,
             contentVersionRepository,
@@ -47,17 +51,9 @@ public ContentVersionService(
             languageRepository,
             entityService,
             contentService,
-            userIdKeyResolver)
+            userIdKeyResolver,
+            contentSettings)
     {
-    /// <summary>
-    /// Gets a content version by its ID.
-    /// </summary>
-    /// <param name="versionId">The version ID.</param>
-    /// <returns>The content version metadata, or null if not found.</returns>
-    /// <inheritdoc />
-    /// <inheritdoc />
-    /// <inheritdoc />
-    /// <inheritdoc />
     }
 
     protected override UmbracoObjectTypes ItemObjectType => UmbracoObjectTypes.Document;
diff --git a/src/Umbraco.Core/Services/ContentVersionServiceBase.cs b/src/Umbraco.Core/Services/ContentVersionServiceBase.cs
index 8a90e0dafc96..461ed0f93a5d 100644
--- a/src/Umbraco.Core/Services/ContentVersionServiceBase.cs
+++ b/src/Umbraco.Core/Services/ContentVersionServiceBase.cs
@@ -1,4 +1,6 @@
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Extensions;
 using Umbraco.Cms.Core.Models;
@@ -24,6 +26,7 @@ internal abstract class ContentVersionServiceBase<TContent>
     private readonly IPublishableContentService<TContent> _contentService;
     private readonly IUserIdKeyResolver _userIdKeyResolver;
     private readonly ILogger<ContentVersionServiceBase<TContent>> _logger;
+    private readonly IOptionsMonitor<ContentSettings> _contentSettings;
     private readonly ICoreScopeProvider _scopeProvider;
 
     protected abstract UmbracoObjectTypes ItemObjectType { get; }
@@ -38,7 +41,8 @@ public ContentVersionServiceBase(
         ILanguageRepository languageRepository,
         IEntityService entityService,
         IPublishableContentService<TContent> contentService,
-        IUserIdKeyResolver userIdKeyResolver)
+        IUserIdKeyResolver userIdKeyResolver,
+        IOptionsMonitor<ContentSettings> contentSettings)
     {
         _logger = logger;
         _contentVersionRepository = contentVersionRepository;
@@ -50,6 +54,7 @@ public ContentVersionServiceBase(
         _entityService = entityService;
         _contentService = contentService;
         _userIdKeyResolver = userIdKeyResolver;
+        _contentSettings = contentSettings;
     }
 
     protected abstract DeletingVersionsNotification<TContent> DeletingVersionsNotification(int id, EventMessages messages, int specificVersion);
@@ -198,53 +203,55 @@ private void HandleSetPreventCleanup(int versionId, bool preventCleanup, int use
     private IReadOnlyCollection<ContentVersionMeta> CleanupItemVersions(DateTime asAtDate)
     {
         List<ContentVersionMeta> versionsToDelete;
+        var fetchWasCapped = false;
 
-        /* Why so many scopes?
-         *
-         * We could just work out the set to delete at SQL infra level which was the original plan, however we agreed that really we should fire
-         * ContentService.DeletingVersions so people can hook & cancel if required.
-         *
-         * On first time run of cleanup on a site with a lot of history there may be a lot of historic ContentVersions to remove e.g. 200K for our.umbraco.com.
-         * If we weren't supporting SQL CE we could do TVP, or use temp tables to bulk delete with joins to our list of version ids to nuke.
-         * (much nicer, we can kill 100k in sub second time-frames).
-         *
-         * However we are supporting SQL CE, so the easiest thing to do is use the Umbraco InGroupsOf helper to create a query with 2K args of version
-         * ids to delete at a time.
-         *
-         * This is already done at the repository level, however if we only had a single scope at service level we're still locking
-         * the ContentVersions table (and other related tables) for a couple of minutes which makes the back office unusable.
-         *
-         * As a quick fix, we can also use InGroupsOf at service level, create a scope per group to give other connections a chance
-         * to grab the locks and execute their queries.
-         *
-         * This makes the back office a tiny bit sluggish during first run but it is usable for loading tree and publishing content.
-         *
-         * There are optimizations we can do, we could add a bulk delete for SqlServerSyntaxProvider which differs in implementation
-         * and fallback to this naive approach only for SQL CE, however we agreed it is not worth the effort as this is a one time pain,
-         * subsequent runs shouldn't have huge numbers of versions to cleanup.
-         *
-         * tl;dr lots of scopes to enable other connections to use the DB whilst we work.
-         */
+        Configuration.Models.ContentVersionCleanupPolicySettings versionCleanupPolicy = _contentSettings.CurrentValue.ContentVersionCleanupPolicy;
+
+        // Use the smallest KeepAllVersionsNewerThanDays across global + per-content-type overrides as the SQL date cutoff.
+        // This may load some rows the C# policy will then keep, but ensures we never miss rows that should be deleted.
+        int effectiveKeepAllDays = versionCleanupPolicy.KeepAllVersionsNewerThanDays;
+        using (_scopeProvider.CreateCoreScope(autoComplete: true))
+        {
+            IReadOnlyCollection<Models.ContentVersionCleanupPolicySettings> overrides =
+                _contentVersionRepository.GetCleanupPolicies();
+            foreach (Models.ContentVersionCleanupPolicySettings policyOverride in overrides)
+            {
+                if (policyOverride.KeepAllVersionsNewerThanDays.HasValue)
+                {
+                    effectiveKeepAllDays = Math.Min(effectiveKeepAllDays, policyOverride.KeepAllVersionsNewerThanDays.Value);
+                }
+            }
+        }
+
+        DateTime olderThan = asAtDate.AddDays(-effectiveKeepAllDays);
+        int? fetchLimit = versionCleanupPolicy.MaxVersionsToDeletePerRun > 0
+            ? versionCleanupPolicy.MaxVersionsToDeletePerRun
+            : null;
+
+        // Multiple scopes are used intentionally so that locks are not held for the entire duration.
+        // This allows other database connections to acquire locks between batches, keeping the backoffice responsive during
+        // large cleanup operations.
         using (ICoreScope scope = _scopeProvider.CreateCoreScope())
         {
             IReadOnlyCollection<ContentVersionMeta> allHistoricVersions =
-                _contentVersionRepository.GetContentVersionsEligibleForCleanup();
+                _contentVersionRepository.GetContentVersionsEligibleForCleanup(olderThan, fetchLimit);
 
             if (allHistoricVersions.Count == 0)
             {
                 scope.Complete();
-                return Array.Empty<ContentVersionMeta>();
+                return [];
             }
 
+            fetchWasCapped = fetchLimit.HasValue && allHistoricVersions.Count >= fetchLimit.Value;
+
             if (_logger.IsEnabled(LogLevel.Debug))
             {
-                _logger.LogDebug("Discovered {count} candidate(s) for ContentVersion cleanup", allHistoricVersions.Count);
+                _logger.LogDebug("Discovered {Count} candidate(s) for ContentVersion cleanup", allHistoricVersions.Count);
             }
 
             versionsToDelete = new List<ContentVersionMeta>(allHistoricVersions.Count);
 
-            IEnumerable<ContentVersionMeta> filteredContentVersions =
-                _contentVersionCleanupPolicy.Apply(asAtDate, allHistoricVersions);
+            IEnumerable<ContentVersionMeta> filteredContentVersions = _contentVersionCleanupPolicy.Apply(asAtDate, allHistoricVersions);
 
             foreach (ContentVersionMeta version in filteredContentVersions)
             {
@@ -254,8 +261,9 @@ private IReadOnlyCollection<ContentVersionMeta> CleanupItemVersions(DateTime asA
                 {
                     if (_logger.IsEnabled(LogLevel.Debug))
                     {
-                        _logger.LogDebug("Delete cancelled for ContentVersion [{versionId}]", version.VersionId);
+                        _logger.LogDebug("Delete cancelled for ContentVersion [{VersionId}]", version.VersionId);
                     }
+
                     continue;
                 }
 
@@ -265,16 +273,20 @@ private IReadOnlyCollection<ContentVersionMeta> CleanupItemVersions(DateTime asA
             scope.Complete();
         }
 
-        if (!versionsToDelete.Any())
+        if (versionsToDelete.Count == 0)
         {
             if (_logger.IsEnabled(LogLevel.Debug))
             {
                 _logger.LogDebug("No remaining ContentVersions for cleanup");
             }
-            return Array.Empty<ContentVersionMeta>();
+
+            return [];
         }
 
-        _logger.LogDebug("Removing {count} ContentVersion(s)", versionsToDelete.Count);
+        if (_logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Removing {Count} ContentVersion(s)", versionsToDelete.Count);
+        }
 
         foreach (IEnumerable<ContentVersionMeta> group in versionsToDelete.InGroupsOf(Constants.Sql.MaxParameterCount))
         {
@@ -295,9 +307,18 @@ private IReadOnlyCollection<ContentVersionMeta> CleanupItemVersions(DateTime asA
             }
         }
 
+        if (fetchWasCapped)
+        {
+            _logger.LogInformation(
+                "Reached per-run cap of {MaxVersionsToDeletePerRun}. Remaining versions will be cleaned up in subsequent runs.",
+                fetchLimit);
+        }
+
         using (ICoreScope scope = _scopeProvider.CreateCoreScope())
         {
+#pragma warning disable CS0618 // Type or member is obsolete
             Audit(AuditType.Delete, Constants.Security.SuperUserId, -1, $"Removed {versionsToDelete.Count} ContentVersion(s) according to cleanup policy");
+#pragma warning restore CS0618 // Type or member is obsolete
 
             scope.Complete();
         }
diff --git a/src/Umbraco.Core/Services/DataTypeService.cs b/src/Umbraco.Core/Services/DataTypeService.cs
index aecf0078f5a1..13fe9c88267f 100644
--- a/src/Umbraco.Core/Services/DataTypeService.cs
+++ b/src/Umbraco.Core/Services/DataTypeService.cs
@@ -181,9 +181,9 @@ public Task<IEnumerable<IDataType>> GetAllAsync(params Guid[] keys)
         }
 
         /// <inheritdoc />
-        public Task<PagedModel<IDataType>> FilterAsync(string? name = null, string? editorUiAlias = null, string? editorAlias = null, int skip = 0, int take = 100)
+        public async Task<PagedModel<IDataType>> FilterAsync(string? name = null, string? editorUiAlias = null, string? editorAlias = null, int skip = 0, int take = 100)
         {
-            IEnumerable<IDataType> query = GetAll();
+            IEnumerable<IDataType> query = await GetAllAsync();
 
             if (name is not null)
             {
@@ -202,11 +202,11 @@ public Task<PagedModel<IDataType>> FilterAsync(string? name = null, string? edit
 
             IDataType[] result = query.ToArray();
 
-            return Task.FromResult(new PagedModel<IDataType>
+            return new PagedModel<IDataType>
             {
                 Total = result.Length,
                 Items = result.Skip(skip).Take(take),
-            });
+            };
         }
 
         /// <summary>
@@ -332,42 +332,6 @@ public async Task<Attempt<IDataType, DataTypeOperationStatus>> MoveAsync(IDataTy
             return Attempt.SucceedWithStatus(DataTypeOperationStatus.Success, toMove);
         }
 
-        /// <summary>
-        ///     Copies a data type to a container.
-        /// </summary>
-        /// <param name="copying">The data type to copy.</param>
-        /// <param name="containerId">The target container ID.</param>
-        /// <param name="userId">The ID of the user performing the action.</param>
-        /// <returns>An operation result containing the copied data type.</returns>
-        public Attempt<OperationResult<MoveOperationStatusType, IDataType>?> Copy(IDataType copying, int containerId, int userId = Constants.Security.SuperUserId)
-        {
-            Guid? containerKey = null;
-            if (containerId > 0)
-            {
-                // mimic obsolete Copy method behavior
-                EntityContainer? container = GetContainer(containerId);
-                if (container is null)
-                {
-                    throw new DataOperationException<MoveOperationStatusType>(MoveOperationStatusType.FailedParentNotFound);
-                }
-
-                containerKey = container.Key;
-            }
-
-            Guid currentUserKey = _userIdKeyResolver.GetAsync(userId).GetAwaiter().GetResult();
-            Attempt<IDataType, DataTypeOperationStatus> result = CopyAsync(copying, containerKey, currentUserKey).GetAwaiter().GetResult();
-
-            // mimic old service behavior
-            EventMessages evtMsgs = EventMessagesFactory.Get();
-            return result.Status switch
-            {
-                DataTypeOperationStatus.Success => OperationResult.Attempt.Succeed(MoveOperationStatusType.Success, evtMsgs, result.Result),
-                DataTypeOperationStatus.CancelledByNotification => OperationResult.Attempt.Fail(MoveOperationStatusType.FailedCancelledByEvent, evtMsgs, result.Result),
-                DataTypeOperationStatus.ParentNotFound => OperationResult.Attempt.Fail(MoveOperationStatusType.FailedParentNotFound, evtMsgs, result.Result),
-                _ => OperationResult.Attempt.Fail(MoveOperationStatusType.FailedNotAllowedByPath, evtMsgs, result.Result, new InvalidOperationException($"Invalid operation status: {result.Status}")),
-            };
-        }
-
         /// <inheritdoc />
         public async Task<Attempt<IDataType, DataTypeOperationStatus>> CopyAsync(IDataType toCopy, Guid? containerKey, Guid userKey)
         {
@@ -484,22 +448,6 @@ public void Save(IEnumerable<IDataType> dataTypeDefinitions, int userId)
             scope.Complete();
         }
 
-        /// <summary>
-        /// Deletes an <see cref="IDataType"/>
-        /// </summary>
-        /// <remarks>
-        /// Please note that deleting a <see cref="IDataType"/> will remove
-        /// all the <see cref="IPropertyType"/> data that references this <see cref="IDataType"/>.
-        /// </remarks>
-        /// <param name="dataType"><see cref="IDataType"/> to delete</param>
-        /// <param name="userId">Optional Id of the user issuing the deletion</param>
-        /// <inheritdoc />
-        public void Delete(IDataType dataType, int userId = Constants.Security.SuperUserId)
-        {
-            Guid currentUserKey = _userIdKeyResolver.GetAsync(userId).GetAwaiter().GetResult();
-            DeleteAsync(dataType.Key, currentUserKey).GetAwaiter().GetResult();
-        }
-
         /// <inheritdoc />
         public async Task<Attempt<IDataType?, DataTypeOperationStatus>> DeleteAsync(Guid id, Guid userKey)
         {
diff --git a/src/Umbraco.Core/Services/DocumentUrlAliasService.cs b/src/Umbraco.Core/Services/DocumentUrlAliasService.cs
index 37ab621ded79..36bfba385b3f 100644
--- a/src/Umbraco.Core/Services/DocumentUrlAliasService.cs
+++ b/src/Umbraco.Core/Services/DocumentUrlAliasService.cs
@@ -340,7 +340,7 @@ public async Task RebuildAllAliasesAsync()
                     toSave.Add(new PublishedDocumentUrlAlias
                     {
                         DocumentKey = raw.DocumentKey,
-                        NullableLanguageId = null, // NULL for invariant content
+                        LanguageId = null, // NULL for invariant content
                         Alias = alias,
                     });
                 }
@@ -352,7 +352,7 @@ public async Task RebuildAllAliasesAsync()
                     toSave.Add(new PublishedDocumentUrlAlias
                     {
                         DocumentKey = raw.DocumentKey,
-                        NullableLanguageId = raw.LanguageId.Value,
+                        LanguageId = raw.LanguageId.Value,
                         Alias = alias,
                     });
                 }
@@ -405,7 +405,7 @@ private async Task<List<PublishedDocumentUrlAlias>> ExtractAliasesFromDocumentAs
                     aliases.Add(new PublishedDocumentUrlAlias
                     {
                         DocumentKey = document.Key,
-                        NullableLanguageId = null, // NULL for invariant content
+                        LanguageId = null, // NULL for invariant content
                         Alias = alias,
                     });
                 }
@@ -430,7 +430,7 @@ private async Task<List<PublishedDocumentUrlAlias>> ExtractAliasesFromDocumentAs
                 aliases.Add(new PublishedDocumentUrlAlias
                 {
                     DocumentKey = document.Key,
-                    NullableLanguageId = language.Id,
+                    LanguageId = language.Id,
                     Alias = alias,
                 });
             }
@@ -486,7 +486,7 @@ private void PopulateCultureToLanguageIdMap(IEnumerable<ILanguage> languages)
     /// </summary>
     private void AddToCache(PublishedDocumentUrlAlias alias)
     {
-        var cacheKey = new AliasCacheKey(alias.Alias, alias.NullableLanguageId);
+        var cacheKey = new AliasCacheKey(alias.Alias, alias.LanguageId);
 
         _aliasCache.AddOrUpdate(
             cacheKey,
@@ -526,7 +526,7 @@ private void AddToCache(PublishedDocumentUrlAlias alias)
     /// This ensures cache updates are rolled back if the database transaction fails.
     /// </summary>
     private void AddToCacheDeferred(IScopeContext scopeContext, PublishedDocumentUrlAlias alias) =>
-        scopeContext.Enlist($"AddAliasToCache_{alias.DocumentKey}_{alias.Alias}_{alias.NullableLanguageId}", () =>
+        scopeContext.Enlist($"AddAliasToCache_{alias.DocumentKey}_{alias.Alias}_{alias.LanguageId}", () =>
         {
             AddToCache(alias);
             return true;
diff --git a/src/Umbraco.Core/Services/DocumentUrlService.cs b/src/Umbraco.Core/Services/DocumentUrlService.cs
index a569b6b97c35..842394a21fc9 100644
--- a/src/Umbraco.Core/Services/DocumentUrlService.cs
+++ b/src/Umbraco.Core/Services/DocumentUrlService.cs
@@ -304,7 +304,7 @@ public async Task RebuildAllUrlsAsync()
         foreach (PublishedDocumentUrlSegment model in publishedDocumentUrlSegments)
         {
             // Group using composite key of document/language/draft.
-            (Guid DocumentKey, int? LanguageId, bool IsDraft) key = (model.DocumentKey, model.NullableLanguageId, model.IsDraft);
+            (Guid DocumentKey, int? LanguageId, bool IsDraft) key = (model.DocumentKey, model.LanguageId, model.IsDraft);
 
             if (grouped.TryGetValue(key, out (string? Primary, List<string> Alternates) segments) is false)
             {
@@ -780,7 +780,7 @@ private static IEnumerable<PublishedDocumentUrlSegment> ConvertToPersistedModel(
         yield return new PublishedDocumentUrlSegment
         {
             DocumentKey = cacheKey.DocumentKey,
-            NullableLanguageId = cacheKey.LanguageId,
+            LanguageId = cacheKey.LanguageId,
             UrlSegment = cache.PrimarySegment,
             IsDraft = cacheKey.IsDraft,
             IsPrimary = true,
@@ -794,7 +794,7 @@ private static IEnumerable<PublishedDocumentUrlSegment> ConvertToPersistedModel(
                 yield return new PublishedDocumentUrlSegment
                 {
                     DocumentKey = cacheKey.DocumentKey,
-                    NullableLanguageId = cacheKey.LanguageId,
+                    LanguageId = cacheKey.LanguageId,
                     UrlSegment = segment,
                     IsDraft = cacheKey.IsDraft,
                     IsPrimary = false,
diff --git a/src/Umbraco.Core/Services/DomainService.cs b/src/Umbraco.Core/Services/DomainService.cs
index 518442930cce..64243527db0d 100644
--- a/src/Umbraco.Core/Services/DomainService.cs
+++ b/src/Umbraco.Core/Services/DomainService.cs
@@ -5,6 +5,7 @@
 using Umbraco.Cms.Core.Notifications;
 using Umbraco.Cms.Core.Persistence.Repositories;
 using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Core.Scoping.EFCore;
 using Umbraco.Cms.Core.Services.OperationStatus;
 using Umbraco.Extensions;
 
@@ -13,7 +14,7 @@ namespace Umbraco.Cms.Core.Services;
 /// <summary>
 /// Provides services for managing domains (hostnames and culture assignments for content).
 /// </summary>
-public class DomainService : RepositoryService, IDomainService
+public class DomainService : AsyncRepositoryService, IDomainService
 {
     private readonly IDomainRepository _domainRepository;
     private readonly ILanguageService _languageService;
@@ -22,14 +23,8 @@ public class DomainService : RepositoryService, IDomainService
     /// <summary>
     /// Initializes a new instance of the <see cref="DomainService"/> class.
     /// </summary>
-    /// <param name="provider">The core scope provider.</param>
-    /// <param name="loggerFactory">The logger factory.</param>
-    /// <param name="eventMessagesFactory">The event messages factory.</param>
-    /// <param name="domainRepository">The domain repository.</param>
-    /// <param name="languageService">The language service.</param>
-    /// <param name="contentService">The content service.</param>
     public DomainService(
-        ICoreScopeProvider provider,
+        IScopeProvider provider,
         ILoggerFactory loggerFactory,
         IEventMessagesFactory eventMessagesFactory,
         IDomainRepository domainRepository,
@@ -43,112 +38,82 @@ public DomainService(
     }
 
     /// <inheritdoc />
-    public bool Exists(string domainName)
+    public async Task<bool> ExistsAsync(string domainName)
     {
-        using (ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true))
-        {
-            return _domainRepository.Exists(domainName);
-        }
-    }
-
-    /// <summary>
-    /// Deletes a domain.
-    /// </summary>
-    /// <param name="domain">The domain to delete.</param>
-    /// <returns>An attempt result indicating the success or failure of the operation.</returns>
-    [Obsolete($"Please use {nameof(UpdateDomainsAsync)}. Scheduled for removal in Umbraco 18.")]
-    public Attempt<OperationResult?> Delete(IDomain domain)
-    {
-        EventMessages eventMessages = EventMessagesFactory.Get();
-        using ICoreScope scope = ScopeProvider.CreateCoreScope();
-
-        var result = DeleteAll(new[] { domain }, scope, eventMessages);
+        using ICoreScope scope = ScopeProvider.CreateScope();
+        var exists = await _domainRepository.ExistsAsync(domainName);
         scope.Complete();
 
-        return result ? OperationResult.Attempt.Succeed(eventMessages) : OperationResult.Attempt.Cancel(eventMessages);
+        return exists;
     }
 
     /// <inheritdoc />
-    public IDomain? GetByName(string name)
+    public async Task<IDomain?> GetByNameAsync(string name)
     {
-        using (ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true))
-        {
-            return _domainRepository.GetByName(name);
-        }
+        using ICoreScope scope = ScopeProvider.CreateScope();
+        IDomain? domain = await _domainRepository.GetByNameAsync(name);
+        scope.Complete();
+
+        return domain;
     }
 
     /// <inheritdoc />
-    public IDomain? GetById(int id)
+    public async Task<IDomain?> GetByIdAsync(int id)
     {
-        using (ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true))
-        {
-            return _domainRepository.Get(id);
-        }
-    }
+        using ICoreScope scope = ScopeProvider.CreateScope();
 
-    /// <summary>
-    /// Gets all domains.
-    /// </summary>
-    /// <param name="includeWildcards">A value indicating whether to include wildcard domains.</param>
-    /// <returns>A collection of all domains.</returns>
-    [Obsolete($"Please use {nameof(GetAllAsync)}. Scheduled for removal in Umbraco 18.")]
-    public IEnumerable<IDomain> GetAll(bool includeWildcards)
-    {
-        using (ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true))
-        {
-            return _domainRepository.GetAll(includeWildcards);
-        }
+        // Gets all from cache and sets the cache again.
+        IEnumerable<IDomain> all = await _domainRepository.GetAllAsync(true);
+        scope.Complete();
+
+        return all.FirstOrDefault(x => x.Id == id);
     }
 
-    /// <summary>
-    /// Gets the domains assigned to a specific content item.
-    /// </summary>
-    /// <param name="contentId">The identifier of the content item.</param>
-    /// <param name="includeWildcards">A value indicating whether to include wildcard domains.</param>
-    /// <returns>A collection of domains assigned to the content item.</returns>
-    [Obsolete($"Please use {nameof(GetAssignedDomainsAsync)}. Scheduled for removal in Umbraco 18.")]
-    public IEnumerable<IDomain> GetAssignedDomains(int contentId, bool includeWildcards)
+    /// <inheritdoc />
+    public async Task<IDomain?> GetByKeyAsync(Guid key)
     {
-        using (ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true))
-        {
-            return _domainRepository.GetAssignedDomains(contentId, includeWildcards);
-        }
+        using ICoreScope scope = ScopeProvider.CreateScope();
+        IDomain? domain = await _domainRepository.GetAsync(key, CancellationToken.None);
+
+        scope.Complete();
+        return domain;
     }
 
-    /// <summary>
-    /// Saves a domain.
-    /// </summary>
-    /// <param name="domainEntity">The domain entity to save.</param>
-    /// <returns>An attempt result indicating the success or failure of the operation.</returns>
-    [Obsolete($"Please use {nameof(UpdateDomainsAsync)}. Scheduled for removal in Umbraco 18.")]
-    public Attempt<OperationResult?> Save(IDomain domainEntity)
+    /// <inheritdoc />
+    public async Task<IEnumerable<IDomain>> GetAssignedDomainsAsync(Guid contentKey, bool includeWildcards)
     {
-        EventMessages eventMessages = EventMessagesFactory.Get();
-        using ICoreScope scope = ScopeProvider.CreateCoreScope();
+        using ICoreScope scope = ScopeProvider.CreateScope();
+        IEnumerable<IDomain> domains = await _domainRepository.GetAssignedDomainsAsync(contentKey, includeWildcards);
 
-        var result = SaveAll(new[] { domainEntity }, scope, eventMessages);
         scope.Complete();
-
-        return result ? OperationResult.Attempt.Succeed(eventMessages) : OperationResult.Attempt.Cancel(eventMessages);
+        return domains;
     }
+
     /// <inheritdoc />
-    public Task<IEnumerable<IDomain>> GetAssignedDomainsAsync(Guid contentKey, bool includeWildcards)
+    // TODO: Remove this method once any usages has been migrated to the key alternative method.
+    public async Task<IEnumerable<IDomain>> GetAssignedDomainsAsync(int contentId, bool includeWildcards)
     {
-        IContent? content = _contentService.GetById(contentKey);
+        using ICoreScope scope = ScopeProvider.CreateScope();
+        IContent? content = _contentService.GetById(contentId);
         if (content == null)
         {
-            return Task.FromResult(Enumerable.Empty<IDomain>());
+            return Enumerable.Empty<IDomain>();
         }
 
-        using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);
-        return Task.FromResult(_domainRepository.GetAssignedDomains(content.Id, includeWildcards));
+        IEnumerable<IDomain> domains = await _domainRepository.GetAssignedDomainsAsync(content.Key, includeWildcards);
+        scope.Complete();
+
+        return domains;
     }
 
     /// <inheritdoc />
-    public Task<IEnumerable<IDomain>> GetAllAsync(bool includeWildcards)
+    public async Task<IEnumerable<IDomain>> GetAllAsync(bool includeWildcards)
     {
-        using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);
-        return Task.FromResult(_domainRepository.GetAll(includeWildcards));
+        using ICoreScope scope = ScopeProvider.CreateScope();
+        IEnumerable<IDomain> domains = await _domainRepository.GetAllAsync(includeWildcards);
+        scope.Complete();
+
+        return domains;
     }
 
     /// <inheritdoc />
@@ -160,7 +125,7 @@ public async Task<Attempt<DomainUpdateResult, DomainOperationStatus>> UpdateDoma
             return Attempt.FailWithStatus(DomainOperationStatus.ContentNotFound, new DomainUpdateResult());
         }
 
-        using ICoreScope scope = ScopeProvider.CreateCoreScope();
+        using ICoreScope scope = ScopeProvider.CreateScope();
 
         IEnumerable<ILanguage> allLanguages = await _languageService.GetAllAsync();
         var languageIdByIsoCode = allLanguages.ToDictionary(l => l.IsoCode, l => l.Id);
@@ -176,7 +141,7 @@ public async Task<Attempt<DomainUpdateResult, DomainOperationStatus>> UpdateDoma
         {
             domainModel.DomainName = domainModel.DomainName.ToLowerInvariant();
 
-            if(Uri.IsWellFormedUriString(domainModel.DomainName, UriKind.RelativeOrAbsolute) is false)
+            if (Uri.IsWellFormedUriString(domainModel.DomainName, UriKind.RelativeOrAbsolute) is false)
             {
                 return Attempt.FailWithStatus(DomainOperationStatus.InvalidDomainName, new DomainUpdateResult());
             }
@@ -211,16 +176,14 @@ public async Task<Attempt<DomainUpdateResult, DomainOperationStatus>> UpdateDoma
         scope.WriteLock(Constants.Locks.Domains);
 
         // delete any obsolete domain assignments
-        if (DeleteAll(currentlyAssignedDomains.Except(newAssignedDomains).ToArray(), scope, eventMessages) == false)
+        if (await DeleteAllAsync(currentlyAssignedDomains.Except(newAssignedDomains).ToArray(), scope, eventMessages) == false)
         {
             scope.Complete();
-
-            // this is the only error scenario in DeleteAll
             return Attempt.FailWithStatus(DomainOperationStatus.CancelledByNotification, new DomainUpdateResult());
         }
 
         // update all domain assignments (also current ones, in case sort order or ISO code has changed)
-        var result = SaveAll(newAssignedDomains, scope, eventMessages);
+        var result = await SaveAllAsync(newAssignedDomains, scope, eventMessages);
         scope.Complete();
 
         return result
@@ -233,9 +196,6 @@ public async Task<Attempt<DomainUpdateResult, DomainOperationStatus>> UpdateDoma
             : Attempt.FailWithStatus(DomainOperationStatus.CancelledByNotification, new DomainUpdateResult());
     }
 
-    /// <summary>
-    /// Tests if any of the ISO codes in the update model are invalid
-    /// </summary>
     private bool HasInvalidIsoCode(DomainsUpdateModel updateModel, IEnumerable<string> allIsoCodes)
         => new[] { updateModel.DefaultIsoCode }
             .Union(updateModel.Domains.Select(domainModel => domainModel.IsoCode))
@@ -243,9 +203,6 @@ private bool HasInvalidIsoCode(DomainsUpdateModel updateModel, IEnumerable<strin
             .Except(allIsoCodes)
             .Any();
 
-    /// <summary>
-    /// Returns any current domain assignments in conflict with the updateModel domain names
-    /// </summary>
     private IDomain[] GetDomainNameConflicts(int contentId, DomainsUpdateModel updateModel, IEnumerable<IDomain> allDomains)
     {
         IDomain[] domainsAssignedToOtherContent = allDomains
@@ -259,12 +216,8 @@ private IDomain[] GetDomainNameConflicts(int contentId, DomainsUpdateModel updat
             .ToArray();
     }
 
-    /// <summary>
-    /// Calculates the new domain assignment incl. wildcard domains
-    /// </summary>
     private IDomain[] CalculateNewAssignedDomains(int contentId, DomainsUpdateModel updateModel, IDomain[] currentlyAssignedDomains, IDictionary<string, int> languageIdByIsoCode)
     {
-        // calculate the assigned domains as they should be after updating (including wildcard domains)
         var newAssignedDomains = new List<IDomain>();
         if (updateModel.DefaultIsoCode.IsNullOrWhiteSpace() == false)
         {
@@ -272,12 +225,10 @@ private IDomain[] CalculateNewAssignedDomains(int contentId, DomainsUpdateModel
                                     ?? new UmbracoDomain($"*{contentId}")
                                     {
                                         LanguageId = languageIdByIsoCode[updateModel.DefaultIsoCode],
-                                        RootContentId = contentId
+                                        RootContentId = contentId,
                                     };
 
-            // wildcard domains should have sort order -1 (lowest possible sort order)
             defaultDomain.SortOrder = -1;
-
             newAssignedDomains.Add(defaultDomain);
         }
 
@@ -286,7 +237,6 @@ private IDomain[] CalculateNewAssignedDomains(int contentId, DomainsUpdateModel
         {
             IDomain? assignedDomain = currentlyAssignedDomains.FirstOrDefault(domain => domainModel.DomainName.InvariantEquals(domain.DomainName));
 
-            // If we do not have an assigned domain, or the domain-language has been changed, create new domain.
             if (assignedDomain is null || assignedDomain.LanguageId != languageIdByIsoCode[domainModel.IsoCode])
             {
                 assignedDomain = new UmbracoDomain(domainModel.DomainName)
@@ -303,10 +253,7 @@ private IDomain[] CalculateNewAssignedDomains(int contentId, DomainsUpdateModel
         return newAssignedDomains.ToArray();
     }
 
-    /// <summary>
-    /// Handles deletion of one or more domains incl. notifications
-    /// </summary>
-    private bool DeleteAll(IDomain[] domainsToDelete, ICoreScope scope, EventMessages eventMessages)
+    private async Task<bool> DeleteAllAsync(IDomain[] domainsToDelete, ICoreScope scope, EventMessages eventMessages)
     {
         if (domainsToDelete.Any() == false)
         {
@@ -321,17 +268,14 @@ private bool DeleteAll(IDomain[] domainsToDelete, ICoreScope scope, EventMessage
 
         foreach (IDomain domainToDelete in domainsToDelete)
         {
-            _domainRepository.Delete(domainToDelete);
+            await _domainRepository.DeleteAsync(domainToDelete, CancellationToken.None);
         }
 
         scope.Notifications.Publish(new DomainDeletedNotification(domainsToDelete, eventMessages).WithStateFrom(deletingNotification));
         return true;
     }
 
-    /// <summary>
-    /// Handles saving of one or more domains incl. notifications
-    /// </summary>
-    private bool SaveAll(IDomain[] domainsToSave, ICoreScope scope, EventMessages eventMessages)
+    private async Task<bool> SaveAllAsync(IDomain[] domainsToSave, ICoreScope scope, EventMessages eventMessages)
     {
         if (domainsToSave.Any() == false)
         {
@@ -346,7 +290,7 @@ private bool SaveAll(IDomain[] domainsToSave, ICoreScope scope, EventMessages ev
 
         foreach (IDomain assignedDomain in domainsToSave)
         {
-            _domainRepository.Save(assignedDomain);
+            await _domainRepository.SaveAsync(assignedDomain, CancellationToken.None);
         }
 
         scope.Notifications.Publish(new DomainSavedNotification(domainsToSave, eventMessages).WithStateFrom(savingNotification));
diff --git a/src/Umbraco.Core/Services/ElementContainerService.cs b/src/Umbraco.Core/Services/ElementContainerService.cs
index e0a01612d0f5..3756882bc3c7 100644
--- a/src/Umbraco.Core/Services/ElementContainerService.cs
+++ b/src/Umbraco.Core/Services/ElementContainerService.cs
@@ -10,6 +10,7 @@
 using Umbraco.Cms.Core.Persistence.Querying;
 using Umbraco.Cms.Core.Persistence.Repositories;
 using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Core.Services.Changes;
 using Umbraco.Cms.Core.Services.OperationStatus;
 using Umbraco.Extensions;
 
@@ -212,13 +213,25 @@ internal async Task<Attempt<EntityContainerOperationStatus>> EmptyRecycleBinAsyn
             return Attempt.Fail(EntityContainerOperationStatus.CancelledByNotification);
         }
 
-        DeleteDescendantsLocked(Constants.System.RecycleBinElementKey, UmbracoObjectTypes.ElementRecycleBin, scope, eventMessages, pageSize);
+        // query root elements in recycle bin and fire deleting notification (cancelable)
+        IQuery<IElement> rootQuery = Query<IElement>().Where(x => x.ParentId == Constants.System.RecycleBinElement);
+        IElement[] rootElements = _elementRepository.Get(rootQuery)?.ToArray() ?? Array.Empty<IElement>();
+
+        var deletingNotification = new ElementDeletingNotification(rootElements, eventMessages);
+        if (await scope.Notifications.PublishCancelableAsync(deletingNotification))
+        {
+            return Attempt.Fail(EntityContainerOperationStatus.CancelledByNotification);
+        }
+
+        List<IElement> deletedElements = DeleteDescendantsLocked(Constants.System.RecycleBinElementKey, UmbracoObjectTypes.ElementRecycleBin, scope, eventMessages, pageSize);
 
         await AuditAsync(AuditType.Delete, userKey, Constants.System.RecycleBinElement, "Recycle bin emptied");
 
         // fire the deleted notification
         scope.Notifications.Publish(new ElementEmptiedRecycleBinNotification(eventMessages).WithStateFrom(emptyingNotification));
 
+        scope.Notifications.Publish(new ElementTreeChangeNotification(deletedElements, TreeChangeTypes.Remove, eventMessages));
+
         scope.Complete();
         return Attempt.Succeed(EntityContainerOperationStatus.Success);
     }
@@ -267,6 +280,7 @@ private async Task<Attempt<EntityContainerOperationStatus>> MoveLockedAsync<TNot
 
         var newContainerPath = $"{parentPath.TrimEnd(Constants.CharArrays.Comma)},{container.Id}";
         var levelDelta = 1 - container.Level + parentLevel;
+        var movedElements = new List<IElement>();
 
         long total;
 
@@ -309,6 +323,7 @@ private async Task<Attempt<EntityContainerOperationStatus>> MoveLockedAsync<TNot
                     //       similar, and at the time of writing this, we are subject to the limitations imposed there.
                     ((TreeEntityBase)descendantElement).Trashed = trash;
                     _elementRepository.Save(descendantElement);
+                    movedElements.Add(descendantElement);
                 }
             }
         }
@@ -326,6 +341,8 @@ private async Task<Attempt<EntityContainerOperationStatus>> MoveLockedAsync<TNot
             : null;
         await AuditAsync(AuditType.Move, userKey, container.Id, auditMessage);
 
+        scope.Notifications.Publish(new ElementTreeChangeNotification(movedElements, TreeChangeTypes.RefreshNode, eventMessages));
+
         // fire the moved notification
         IStatefulNotification movedNotification = movedNotificationFactory(container, eventMessages);
         scope.Notifications.Publish(movedNotification.WithStateFrom(movingNotification));
@@ -359,7 +376,7 @@ private async Task<Attempt<EntityContainerOperationStatus>> MoveLockedAsync<TNot
             return Attempt.FailWithStatus<EntityContainer?, EntityContainerOperationStatus>(EntityContainerOperationStatus.CancelledByNotification, container);
         }
 
-        DeleteDescendantsLocked(container.Key, UmbracoObjectTypes.ElementContainer, scope, eventMessages);
+        List<IElement> deletedElements = DeleteDescendantsLocked(container.Key, UmbracoObjectTypes.ElementContainer, scope, eventMessages);
 
         DeleteContainerRelations(container);
         _entityContainerRepository.Delete(container);
@@ -368,12 +385,15 @@ private async Task<Attempt<EntityContainerOperationStatus>> MoveLockedAsync<TNot
 
         // fire the deleted notification
         scope.Notifications.Publish(new EntityContainerDeletedNotification(container, eventMessages).WithStateFrom(deletingNotification));
+        scope.Notifications.Publish(new ElementTreeChangeNotification(deletedElements, TreeChangeTypes.Remove, eventMessages));
 
         return Attempt.SucceedWithStatus<EntityContainer?, EntityContainerOperationStatus>(EntityContainerOperationStatus.Success, container);
     }
 
-    private void DeleteDescendantsLocked(Guid key, UmbracoObjectTypes objectType, ICoreScope scope, EventMessages eventMessages, int pageSize = DescendantsIteratorPageSize)
+    private List<IElement> DeleteDescendantsLocked(Guid key, UmbracoObjectTypes objectType, ICoreScope scope, EventMessages eventMessages, int pageSize = DescendantsIteratorPageSize)
     {
+        var deletedElements = new List<IElement>();
+
         // Order by path descending to ensure children are deleted before parents
         var pathDescendingOrdering = Ordering.By("Path", Direction.Descending);
 
@@ -425,15 +445,21 @@ private void DeleteDescendantsLocked(Guid key, UmbracoObjectTypes objectType, IC
                     continue;
                 }
 
-                DeleteItem(scope, descendant, eventMessages);
+                IUmbracoEntity deletedEntity = DeleteItem(scope, descendant, eventMessages);
+                if (deletedEntity is IElement deletedElement)
+                {
+                    deletedElements.Add(deletedElement);
+                }
             }
 
             // Track the smallest path we've seen (last in descending order) as cursor for next iteration
             lastProcessedPath = descendants[^1].Path;
         }
+
+        return deletedElements;
     }
 
-    private void DeleteItem(ICoreScope scope, IEntitySlim descendant, EventMessages eventMessages)
+    private IUmbracoEntity DeleteItem(ICoreScope scope, IEntitySlim descendant, EventMessages eventMessages)
     {
         if (descendant.NodeObjectType == Constants.ObjectTypes.ElementContainer)
         {
@@ -442,14 +468,14 @@ private void DeleteItem(ICoreScope scope, IEntitySlim descendant, EventMessages
                                                   ?? throw new InvalidOperationException($"Descendant container with ID {descendant.Id} was not found.");
             _entityContainerRepository.Delete(descendantContainer);
             scope.Notifications.Publish(new EntityContainerDeletedNotification(descendantContainer, eventMessages));
+            return descendantContainer;
         }
-        else
-        {
-            IElement descendantElement = _elementRepository.Get(descendant.Id)
-                                         ?? throw new InvalidOperationException($"Descendant element with ID {descendant.Id} was not found.");
-            _elementRepository.Delete(descendantElement);
-            scope.Notifications.Publish(new ElementDeletedNotification(descendantElement, eventMessages));
-        }
+
+        IElement descendantElement = _elementRepository.Get(descendant.Id)
+                                     ?? throw new InvalidOperationException($"Descendant element with ID {descendant.Id} was not found.");
+        _elementRepository.Delete(descendantElement);
+        scope.Notifications.Publish(new ElementDeletedNotification(descendantElement, eventMessages));
+        return descendantElement;
     }
 
     private void DeleteContainerRelations(IEntity container)
diff --git a/src/Umbraco.Core/Services/ElementEditingService.cs b/src/Umbraco.Core/Services/ElementEditingService.cs
index 183f1e020913..8152749e69a4 100644
--- a/src/Umbraco.Core/Services/ElementEditingService.cs
+++ b/src/Umbraco.Core/Services/ElementEditingService.cs
@@ -9,6 +9,7 @@
 using Umbraco.Cms.Core.Notifications;
 using Umbraco.Cms.Core.PropertyEditors;
 using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Core.Services.Changes;
 using Umbraco.Cms.Core.Services.Filters;
 using Umbraco.Cms.Core.Services.OperationStatus;
 using Umbraco.Extensions;
@@ -420,6 +421,8 @@ private async Task<Attempt<ContentEditingOperationStatus>> MoveLockedAsync<TNoti
             : null;
         await _auditService.AddAsync(AuditType.Move, userKey, toMove.Id, UmbracoObjectTypes.Element.GetName(), auditMessage);
 
+        scope.Notifications.Publish(new ElementTreeChangeNotification(toMove, TreeChangeTypes.RefreshBranch, eventMessages));
+
         IStatefulNotification movedNotification = movedNotificationFactory(toMove, eventMessages);
         scope.Notifications.Publish(movedNotification.WithStateFrom(movingNotification));
 
@@ -452,7 +455,7 @@ private async Task<Attempt<ContentEditingOperationStatus>> MoveLockedAsync<TNoti
         IElement copy = element.DeepCloneWithResetIdentities();
         copy.ParentId = newParentId;
 
-        var copyingNotification = new ElementCopyingNotification(element, copy, newParentId, newParentKey, eventMessages);
+        var copyingNotification = new ElementCopyingNotification(element, copy, newParentKey, eventMessages);
         if (await scope.Notifications.PublishCancelableAsync(copyingNotification))
         {
             scope.Complete();
@@ -473,8 +476,9 @@ private async Task<Attempt<ContentEditingOperationStatus>> MoveLockedAsync<TNoti
             return null;
         }
 
+        scope.Notifications.Publish(new ElementTreeChangeNotification(copy, TreeChangeTypes.RefreshBranch, eventMessages));
         scope.Notifications.Publish(
-            new ElementCopiedNotification(element, copy, newParentId, newParentKey, relateToOriginal, eventMessages)
+            new ElementCopiedNotification(element, copy, newParentKey, relateToOriginal, eventMessages)
                 .WithStateFrom(copyingNotification));
 
         await _auditService.AddAsync(AuditType.Copy, userKey, element.Id, UmbracoObjectTypes.Element.GetName());
diff --git a/src/Umbraco.Core/Services/ElementVersionService.cs b/src/Umbraco.Core/Services/ElementVersionService.cs
index c14f8b450b27..c36b2d116b78 100644
--- a/src/Umbraco.Core/Services/ElementVersionService.cs
+++ b/src/Umbraco.Core/Services/ElementVersionService.cs
@@ -1,4 +1,6 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Notifications;
@@ -11,7 +13,7 @@ internal sealed class ElementVersionService : ContentVersionServiceBase<IElement
 {
     public ElementVersionService(
         ILogger<ElementVersionService> logger,
-        IElementVersionRepository contentVersionRepository,
+        IElementVersionRepository elementVersionRepository,
         IContentVersionCleanupPolicy contentVersionCleanupPolicy,
         ICoreScopeProvider scopeProvider,
         IEventMessagesFactory eventMessagesFactory,
@@ -19,10 +21,11 @@ public ElementVersionService(
         ILanguageRepository languageRepository,
         IEntityService entityService,
         IElementService contentService,
-        IUserIdKeyResolver userIdKeyResolver)
+        IUserIdKeyResolver userIdKeyResolver,
+        IOptionsMonitor<ContentSettings> contentSettings)
         : base(
             logger,
-            contentVersionRepository,
+            elementVersionRepository,
             contentVersionCleanupPolicy,
             scopeProvider,
             eventMessagesFactory,
@@ -30,7 +33,8 @@ public ElementVersionService(
             languageRepository,
             entityService,
             contentService,
-            userIdKeyResolver)
+            userIdKeyResolver,
+            contentSettings)
     {
     }
 
diff --git a/src/Umbraco.Core/Services/FileService.cs b/src/Umbraco.Core/Services/FileService.cs
index e46c10056745..588979828acf 100644
--- a/src/Umbraco.Core/Services/FileService.cs
+++ b/src/Umbraco.Core/Services/FileService.cs
@@ -287,52 +287,6 @@ public void SaveScript(IScript? script, int? userId)
     #endregion
 
     #region Templates
-    /// <summary>
-    ///     Create a new template, setting the content if a view exists in the filesystem
-    /// </summary>
-    /// <param name="name"></param>
-    /// <param name="alias"></param>
-    /// <param name="content"></param>
-    /// <param name="masterTemplate"></param>
-    /// <param name="userId"></param>
-    /// <returns></returns>
-    [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
-    public ITemplate CreateTemplateWithIdentity(
-        string? name,
-        string? alias,
-        string? content,
-        ITemplate? masterTemplate = null,
-        int userId = Constants.Security.SuperUserId)
-    {
-        // mimic old service behavior
-        ArgumentException.ThrowIfNullOrEmpty(name);
-        ArgumentException.ThrowIfNullOrEmpty(alias);
-        if (name.Length > 255)
-        {
-            throw new ArgumentOutOfRangeException(nameof(name), "Name cannot be more than 255 characters in length.");
-        }
-
-        Guid currentUserKey = _userIdKeyResolver.GetAsync(userId).GetAwaiter().GetResult();
-        Attempt<ITemplate, TemplateOperationStatus> result = _templateService.CreateAsync(name, alias, content, currentUserKey).GetAwaiter().GetResult();
-        return result.Result;
-    }
-
-    /// <summary>
-    ///     Gets a list of all <see cref="ITemplate" /> objects
-    /// </summary>
-    /// <returns>An enumerable list of <see cref="ITemplate" /> objects</returns>
-    [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
-    public IEnumerable<ITemplate> GetTemplates(params string[] aliases)
-        => _templateService.GetAllAsync(aliases).GetAwaiter().GetResult();
-
-    /// <summary>
-    ///     Gets a list of all <see cref="ITemplate" /> objects
-    /// </summary>
-    /// <returns>An enumerable list of <see cref="ITemplate" /> objects</returns>
-    [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
-    public IEnumerable<ITemplate> GetTemplates(int masterTemplateId)
-        => _templateService.GetChildrenAsync(masterTemplateId).GetAwaiter().GetResult();
-
     /// <summary>
     ///     Gets a <see cref="ITemplate" /> object by its alias.
     /// </summary>
@@ -368,49 +322,6 @@ public IEnumerable<ITemplate> GetTemplates(int masterTemplateId)
     [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
     public IEnumerable<ITemplate> GetTemplateDescendants(int masterTemplateId)
         => _templateService.GetDescendantsAsync(masterTemplateId).GetAwaiter().GetResult();
-
-    /// <summary>
-    ///     Saves a <see cref="Template" />
-    /// </summary>
-    /// <param name="template"><see cref="Template" /> to save</param>
-    /// <param name="userId"></param>
-    [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
-    public void SaveTemplate(ITemplate template, int userId = Constants.Security.SuperUserId)
-    {
-        // mimic old service behavior
-        if (template == null)
-        {
-            throw new ArgumentNullException(nameof(template));
-        }
-
-        if (string.IsNullOrWhiteSpace(template.Name) || template.Name.Length > 255)
-        {
-            throw new InvalidOperationException(
-                "Name cannot be null, empty, contain only white-space characters or be more than 255 characters in length.");
-        }
-
-        Guid currentUserKey = _userIdKeyResolver.GetAsync(userId).GetAwaiter().GetResult();
-        if (template.Id > 0)
-        {
-            _templateService.UpdateAsync(template, currentUserKey).GetAwaiter().GetResult();
-        }
-        else
-        {
-            _templateService.CreateAsync(template, currentUserKey).GetAwaiter().GetResult();
-        }
-    }
-
-    /// <summary>
-    ///     Deletes a template by its alias
-    /// </summary>
-    /// <param name="alias">Alias of the <see cref="ITemplate" /> to delete</param>
-    /// <param name="userId"></param>
-    [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
-    public void DeleteTemplate(string alias, int userId = Constants.Security.SuperUserId)
-    {
-        Guid currentUserKey = _userIdKeyResolver.GetAsync(userId).GetAwaiter().GetResult();
-        _templateService.DeleteAsync(alias, currentUserKey).GetAwaiter().GetResult();
-    }
     #endregion
 
     #region Partial Views
diff --git a/src/Umbraco.Core/Services/IContentService.cs b/src/Umbraco.Core/Services/IContentService.cs
index 98f78fe1ae1b..3e3c58a793e0 100644
--- a/src/Umbraco.Core/Services/IContentService.cs
+++ b/src/Umbraco.Core/Services/IContentService.cs
@@ -37,20 +37,17 @@ public interface IContentService : IPublishableContentService<IContent>
     ///     Saves a blueprint.
     /// </summary>
     /// <param name="content">The blueprint to save.</param>
+    /// <param name="createdFromContent">The content from which the blueprint was created.</param>
     /// <param name="userId">The identifier of the user performing the action.</param>
-    [Obsolete("Please use the method taking all parameters. Scheduled for removal in Umbraco 18.")]
-    void SaveBlueprint(IContent content, int userId = Constants.Security.SuperUserId);
+    void SaveBlueprint(IContent content, IContent? createdFromContent, int userId = Constants.Security.SuperUserId);
 
     /// <summary>
-    ///     Saves a blueprint.
+    ///     Moves a blueprint.
     /// </summary>
-    /// <param name="content">The blueprint to save.</param>
-    /// <param name="createdFromContent">The content from which the blueprint was created.</param>
+    /// <param name="content">The blueprint to move.</param>
     /// <param name="userId">The identifier of the user performing the action.</param>
-    void SaveBlueprint(IContent content, IContent? createdFromContent, int userId = Constants.Security.SuperUserId)
-#pragma warning disable CS0618 // Type or member is obsolete
-        => SaveBlueprint(content, userId);
-#pragma warning restore CS0618 // Type or member is obsolete
+    // TODO (V19): Remove the default implementation from this
+    void MoveBlueprint(IContent content, int userId = Constants.Security.SuperUserId) => throw new NotImplementedException();
 
     /// <summary>
     ///     Deletes a blueprint.
@@ -297,13 +294,6 @@ IEnumerable<IContent> GetPagedChildren(int id, long pageIndex, int pageSize, out
     [Obsolete("Use GetContentSchedulesByKeys instead. Scheduled for removal in Umbraco 19.")]
     IDictionary<int, IEnumerable<ContentSchedule>> GetContentSchedulesByIds(Guid[] keys) => ImmutableDictionary<int, IEnumerable<ContentSchedule>>.Empty;
 
-    /// <summary>
-    ///     Gets a dictionary of content keys and their matching content schedules.
-    /// </summary>
-    /// <param name="keys">The content keys.</param>
-    /// <returns>A dictionary with a content key and an IEnumerable of matching ContentSchedules.</returns>
-    IDictionary<Guid, IEnumerable<ContentSchedule>> GetContentSchedulesByKeys(Guid[] keys) => ImmutableDictionary<Guid, IEnumerable<ContentSchedule>>.Empty;
-
     #endregion
 
     #region Save, Delete Document
diff --git a/src/Umbraco.Core/Services/IContentTypeBaseService.cs b/src/Umbraco.Core/Services/IContentTypeBaseService.cs
index 8cd1241fe7db..d122cc2e86f0 100644
--- a/src/Umbraco.Core/Services/IContentTypeBaseService.cs
+++ b/src/Umbraco.Core/Services/IContentTypeBaseService.cs
@@ -305,28 +305,6 @@ Task<Attempt<ContentTypeOperationStatus>> UpdateAsync(TItem item, Guid performin
     [Obsolete("Please use CopyAsync. Scheduled for removal in Umbraco 18.")]
     Attempt<OperationResult<MoveOperationStatusType, TItem>?> Copy(TItem copying, int containerId);
 
-    /// <summary>
-    ///     Copies a content type with a new alias and name.
-    /// </summary>
-    /// <param name="original">The content type to copy.</param>
-    /// <param name="alias">The alias for the copy.</param>
-    /// <param name="name">The name for the copy.</param>
-    /// <param name="parentId">The identifier of the parent container.</param>
-    /// <returns>The copied content type.</returns>
-    [Obsolete("Please use CopyAsync. Scheduled for removal in Umbraco 18.")]
-    TItem Copy(TItem original, string alias, string name, int parentId = -1);
-
-    /// <summary>
-    ///     Copies a content type with a new alias and name under a parent.
-    /// </summary>
-    /// <param name="original">The content type to copy.</param>
-    /// <param name="alias">The alias for the copy.</param>
-    /// <param name="name">The name for the copy.</param>
-    /// <param name="parent">The parent content type.</param>
-    /// <returns>The copied content type.</returns>
-    [Obsolete("Please use CopyAsync. Scheduled for removal in Umbraco 18.")]
-    TItem Copy(TItem original, string alias, string name, TItem parent);
-
     /// <summary>
     ///     Copies a content type to a container asynchronously.
     /// </summary>
diff --git a/src/Umbraco.Core/Services/IDataTypeService.cs b/src/Umbraco.Core/Services/IDataTypeService.cs
index aa4e8597f3e3..731c8f40455a 100644
--- a/src/Umbraco.Core/Services/IDataTypeService.cs
+++ b/src/Umbraco.Core/Services/IDataTypeService.cs
@@ -157,18 +157,6 @@ Task<PagedModel<RelationItemModel>> GetPagedRelationsAsync(Guid key, int skip, i
     /// <param name="userKey">Key of the user issuing the update</param>
     Task<Attempt<IDataType, DataTypeOperationStatus>> UpdateAsync(IDataType dataType, Guid userKey);
 
-    /// <summary>
-    ///     Deletes an <see cref="IDataType" />
-    /// </summary>
-    /// <remarks>
-    ///     Please note that deleting a <see cref="IDataType" /> will remove
-    ///     all the <see cref="IPropertyType" /> data that references this <see cref="IDataType" />.
-    /// </remarks>
-    /// <param name="dataType"><see cref="IDataType" /> to delete</param>
-    /// <param name="userId">Id of the user issuing the deletion</param>
-    [Obsolete("Please use DeleteAsync. Scheduled for removal in Umbraco 18.")]
-    void Delete(IDataType dataType, int userId = Constants.Security.SuperUserId);
-
     /// <summary>
     ///     Deletes an <see cref="IDataType" />
     /// </summary>
@@ -211,19 +199,6 @@ Task<PagedModel<RelationItemModel>> GetPagedRelationsAsync(Guid key, int skip, i
     /// <returns>An attempt result with the moved data type and operation status.</returns>
     Task<Attempt<IDataType, DataTypeOperationStatus>> MoveAsync(IDataType toMove, Guid? containerKey, Guid userKey);
 
-    /// <summary>
-    ///     Copies a <see cref="IDataType" /> to a given container.
-    /// </summary>
-    /// <param name="copying">The data type to copy.</param>
-    /// <param name="containerId">The ID of the target container.</param>
-    /// <param name="userId">The ID of the user performing the action.</param>
-    /// <returns>An operation result containing the copied data type.</returns>
-    [Obsolete("Please use CopyAsync instead. Scheduled for removal in Umbraco 18.")]
-    Attempt<OperationResult<MoveOperationStatusType, IDataType>?> Copy(
-        IDataType copying,
-        int containerId,
-        int userId = Constants.Security.SuperUserId) => throw new NotImplementedException();
-
     /// <summary>
     /// Copies a <see cref="IDataType"/> to a given container
     /// </summary>
diff --git a/src/Umbraco.Core/Services/IDomainService.cs b/src/Umbraco.Core/Services/IDomainService.cs
index 4acfe4b49443..f0a57303af3a 100644
--- a/src/Umbraco.Core/Services/IDomainService.cs
+++ b/src/Umbraco.Core/Services/IDomainService.cs
@@ -1,4 +1,3 @@
-using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.ContentEditing;
 using Umbraco.Cms.Core.Services.OperationStatus;
@@ -19,62 +18,46 @@ public interface IDomainService : IService
     /// </summary>
     /// <param name="domainName">The domain name to check.</param>
     /// <returns><c>true</c> if the domain exists; otherwise, <c>false</c>.</returns>
-    bool Exists(string domainName);
-
-    /// <summary>
-    ///     Deletes a domain.
-    /// </summary>
-    /// <param name="domain">The domain to delete.</param>
-    /// <returns>An attempt containing the operation result.</returns>
-    [Obsolete($"Please use {nameof(UpdateDomainsAsync)}. Scheduled for removal in Umbraco 18.")]
-    Attempt<OperationResult?> Delete(IDomain domain);
+    Task<bool> ExistsAsync(string domainName);
 
     /// <summary>
     ///     Gets a domain by its name.
     /// </summary>
     /// <param name="name">The domain name.</param>
     /// <returns>The domain, or <c>null</c> if not found.</returns>
-    IDomain? GetByName(string name);
+    Task<IDomain?> GetByNameAsync(string name);
 
     /// <summary>
     ///     Gets a domain by its identifier.
     /// </summary>
     /// <param name="id">The domain identifier.</param>
     /// <returns>The domain, or <c>null</c> if not found.</returns>
-    IDomain? GetById(int id);
+    [Obsolete("Use key-based overloads instead. Scheduled for removal when EFCore migration is completed.")]
+    Task<IDomain?> GetByIdAsync(int id);
 
     /// <summary>
-    ///     Gets all domains.
+    ///     Gets a domain by its key.
     /// </summary>
-    /// <param name="includeWildcards">Whether to include wildcard domains.</param>
-    /// <returns>A collection of domains.</returns>
-    [Obsolete($"Please use {nameof(GetAllAsync)}. Scheduled for removal in Umbraco 18.")]
-    IEnumerable<IDomain> GetAll(bool includeWildcards);
+    /// <param name="key">The domain key.</param>
+    /// <returns>The domain, or <c>null</c> if not found.</returns>
+    Task<IDomain?> GetByKeyAsync(Guid key);
 
     /// <summary>
-    ///     Gets all domains assigned to a content item.
+    ///     Gets all assigned domains for a content item by its key.
     /// </summary>
-    /// <param name="contentId">The content item identifier.</param>
+    /// <param name="contentKey">The unique identifier of the content item.</param>
     /// <param name="includeWildcards">Whether to include wildcard domains.</param>
     /// <returns>A collection of domains assigned to the content item.</returns>
-    [Obsolete($"Please use {nameof(GetAssignedDomainsAsync)}. Scheduled for removal in Umbraco 18.")]
-    IEnumerable<IDomain> GetAssignedDomains(int contentId, bool includeWildcards);
-
-    /// <summary>
-    ///     Saves a domain.
-    /// </summary>
-    /// <param name="domainEntity">The domain to save.</param>
-    /// <returns>An attempt containing the operation result.</returns>
-    [Obsolete($"Please use {nameof(UpdateDomainsAsync)}. Scheduled for removal in Umbraco 18.")]
-    Attempt<OperationResult?> Save(IDomain domainEntity);
+    Task<IEnumerable<IDomain>> GetAssignedDomainsAsync(Guid contentKey, bool includeWildcards);
 
     /// <summary>
-    ///     Gets all assigned domains for a content item.
+    ///     Gets all assigned domains for a content item by its integer identifier.
     /// </summary>
-    /// <param name="contentKey">The unique identifier of the content item.</param>
+    /// <param name="contentId">The integer identifier of the content item.</param>
     /// <param name="includeWildcards">Whether to include wildcard domains.</param>
     /// <returns>A collection of domains assigned to the content item.</returns>
-    Task<IEnumerable<IDomain>> GetAssignedDomainsAsync(Guid contentKey, bool includeWildcards);
+    [Obsolete("Use the Guid key overload instead. Scheduled for removal when EFCore migration is completed.")]
+    Task<IEnumerable<IDomain>> GetAssignedDomainsAsync(int contentId, bool includeWildcards);
 
     /// <summary>
     ///     Gets all assigned domains.
diff --git a/src/Umbraco.Core/Services/IFileService.cs b/src/Umbraco.Core/Services/IFileService.cs
index 7a97228a9b8d..686c757c4a07 100644
--- a/src/Umbraco.Core/Services/IFileService.cs
+++ b/src/Umbraco.Core/Services/IFileService.cs
@@ -57,20 +57,6 @@ public interface IFileService : IService
     [Obsolete("Please use IScriptService for script operations. Scheduled for removal in Umbraco 18.")]
     void SaveScript(IScript? script, int? userId = Constants.Security.SuperUserId);
 
-    /// <summary>
-    ///     Gets a list of all <see cref="ITemplate" /> objects
-    /// </summary>
-    /// <returns>An enumerable list of <see cref="ITemplate" /> objects</returns>
-    [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
-    IEnumerable<ITemplate> GetTemplates(params string[] aliases);
-
-    /// <summary>
-    ///     Gets a list of all <see cref="ITemplate" /> objects
-    /// </summary>
-    /// <returns>An enumerable list of <see cref="ITemplate" /> objects</returns>
-    [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
-    IEnumerable<ITemplate> GetTemplates(int masterTemplateId);
-
     /// <summary>
     ///     Gets a <see cref="ITemplate" /> object by its alias.
     /// </summary>
@@ -86,32 +72,4 @@ public interface IFileService : IService
     /// <returns>The <see cref="ITemplate" /> object matching the identifier, or null.</returns>
     [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
     ITemplate? GetTemplate(int id);
-
-    /// <summary>
-    ///     Saves a <see cref="ITemplate" />
-    /// </summary>
-    /// <param name="template"><see cref="ITemplate" /> to save</param>
-    /// <param name="userId">Optional id of the user saving the template</param>
-    [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
-    void SaveTemplate(ITemplate template, int userId = Constants.Security.SuperUserId);
-
-    /// <summary>
-    ///     Creates a new template with identity, setting the content if a view exists in the filesystem.
-    /// </summary>
-    /// <param name="name">The name of the template.</param>
-    /// <param name="alias">The alias of the template.</param>
-    /// <param name="content">The content/markup of the template.</param>
-    /// <param name="masterTemplate">Optional master template.</param>
-    /// <param name="userId">Optional id of the user creating the template.</param>
-    /// <returns>The created <see cref="ITemplate" />.</returns>
-    [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
-    ITemplate CreateTemplateWithIdentity(string? name, string? alias, string? content, ITemplate? masterTemplate = null, int userId = Constants.Security.SuperUserId);
-
-    /// <summary>
-    ///     Deletes a template by its alias
-    /// </summary>
-    /// <param name="alias">Alias of the <see cref="ITemplate" /> to delete</param>
-    /// <param name="userId">Optional id of the user deleting the template</param>
-    [Obsolete("Please use ITemplateService for template operations. Scheduled for removal in Umbraco 18.")]
-    void DeleteTemplate(string alias, int userId = Constants.Security.SuperUserId);
 }
diff --git a/src/Umbraco.Core/Services/ILocalizationService.cs b/src/Umbraco.Core/Services/ILocalizationService.cs
index 69d99ef1525d..e560883ce6c4 100644
--- a/src/Umbraco.Core/Services/ILocalizationService.cs
+++ b/src/Umbraco.Core/Services/ILocalizationService.cs
@@ -14,16 +14,6 @@ public interface ILocalizationService : IService
     // Add/Set Text (Insert/Update)
     // Remove Text (in translation)
 
-    /// <summary>
-    ///     Creates and saves a new dictionary item and assigns a value to all languages if defaultValue is specified.
-    /// </summary>
-    /// <param name="key"></param>
-    /// <param name="parentId"></param>
-    /// <param name="defaultValue"></param>
-    /// <returns></returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    IDictionaryItem CreateDictionaryItemWithIdentity(string key, Guid? parentId, string? defaultValue = null);
-
     /// <summary>
     ///     Gets a <see cref="IDictionaryItem" /> by its <see cref="int" /> id
     /// </summary>
@@ -44,16 +34,6 @@ public interface ILocalizationService : IService
     [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
     IDictionaryItem? GetDictionaryItemById(Guid id);
 
-    /// <summary>
-    ///     Gets a collection of <see cref="IDictionaryItem" /> by their <see cref="Guid" /> ids
-    /// </summary>
-    /// <param name="ids">Ids of the <see cref="IDictionaryItem" /></param>
-    /// <returns>
-    ///     A collection of <see cref="IDictionaryItem" />
-    /// </returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    IEnumerable<IDictionaryItem> GetDictionaryItemsByIds(params Guid[] ids) => Array.Empty<IDictionaryItem>();
-
     /// <summary>
     ///     Gets a <see cref="IDictionaryItem" /> by its key
     /// </summary>
@@ -64,16 +44,6 @@ public interface ILocalizationService : IService
     [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
     IDictionaryItem? GetDictionaryItemByKey(string key);
 
-    /// <summary>
-    ///     Gets a collection of <see cref="IDictionaryItem" /> by their keys
-    /// </summary>
-    /// <param name="keys">Keys of the <see cref="IDictionaryItem" /></param>
-    /// <returns>
-    ///     A collection of <see cref="IDictionaryItem" />
-    /// </returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    IEnumerable<IDictionaryItem> GetDictionaryItemsByKeys(params string[] keys) => Array.Empty<IDictionaryItem>();
-
     /// <summary>
     ///     Gets a list of children for a <see cref="IDictionaryItem" />
     /// </summary>
@@ -82,29 +52,6 @@ public interface ILocalizationService : IService
     [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
     IEnumerable<IDictionaryItem> GetDictionaryItemChildren(Guid parentId);
 
-    /// <summary>
-    ///     Gets a list of descendants for a <see cref="IDictionaryItem" />
-    /// </summary>
-    /// <param name="parentId">Id of the parent, null will return all dictionary items</param>
-    /// <returns>An enumerable list of <see cref="IDictionaryItem" /> objects</returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    IEnumerable<IDictionaryItem> GetDictionaryItemDescendants(Guid? parentId);
-
-    /// <summary>
-    ///     Gets the root/top <see cref="IDictionaryItem" /> objects
-    /// </summary>
-    /// <returns>An enumerable list of <see cref="IDictionaryItem" /> objects</returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    IEnumerable<IDictionaryItem> GetRootDictionaryItems();
-
-    /// <summary>
-    ///     Checks if a <see cref="IDictionaryItem" /> with given key exists
-    /// </summary>
-    /// <param name="key">Key of the <see cref="IDictionaryItem" /></param>
-    /// <returns>True if a <see cref="IDictionaryItem" /> exists, otherwise false</returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    bool DictionaryItemExists(string key);
-
     /// <summary>
     ///     Saves a <see cref="IDictionaryItem" /> object
     /// </summary>
@@ -113,15 +60,6 @@ public interface ILocalizationService : IService
     [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
     void Save(IDictionaryItem dictionaryItem, int userId = Constants.Security.SuperUserId);
 
-    /// <summary>
-    ///     Deletes a <see cref="IDictionaryItem" /> object and its related translations
-    ///     as well as its children.
-    /// </summary>
-    /// <param name="dictionaryItem"><see cref="IDictionaryItem" /> to delete</param>
-    /// <param name="userId">Optional id of the user deleting the dictionary item</param>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    void Delete(IDictionaryItem dictionaryItem, int userId = Constants.Security.SuperUserId);
-
     /// <summary>
     ///     Gets a <see cref="ILanguage" /> by its id
     /// </summary>
@@ -142,15 +80,6 @@ public interface ILocalizationService : IService
     [Obsolete("Please use ILanguageService for language operations. Scheduled for removal in Umbraco 18.")]
     ILanguage? GetLanguageByIsoCode(string? isoCode);
 
-    /// <summary>
-    ///     Gets a language identifier from its ISO code.
-    /// </summary>
-    /// <remarks>
-    ///     <para>This can be optimized and bypass all deep cloning.</para>
-    /// </remarks>
-    [Obsolete("Please use ILanguageService for language operations. Scheduled for removal in Umbraco 18.")]
-    int? GetLanguageIdByIsoCode(string isoCode);
-
     /// <summary>
     ///     Gets the default language ISO code.
     /// </summary>
@@ -183,12 +112,4 @@ public interface ILocalizationService : IService
     /// <param name="userId">Optional id of the user saving the language</param>
     [Obsolete("Please use ILanguageService for language operations. Scheduled for removal in Umbraco 18.")]
     void Save(ILanguage language, int userId = Constants.Security.SuperUserId);
-
-    /// <summary>
-    ///     Deletes a <see cref="ILanguage" /> by removing it and its usages from the db
-    /// </summary>
-    /// <param name="language"><see cref="ILanguage" /> to delete</param>
-    /// <param name="userId">Optional id of the user deleting the language</param>
-    [Obsolete("Please use ILanguageService for language operations. Scheduled for removal in Umbraco 18.")]
-    void Delete(ILanguage language, int userId = Constants.Security.SuperUserId);
 }
diff --git a/src/Umbraco.Core/Services/IMemberGroupService.cs b/src/Umbraco.Core/Services/IMemberGroupService.cs
index 135709302236..e3745e9fb3e5 100644
--- a/src/Umbraco.Core/Services/IMemberGroupService.cs
+++ b/src/Umbraco.Core/Services/IMemberGroupService.cs
@@ -23,14 +23,6 @@ public interface IMemberGroupService : IService
     [Obsolete("Please use Guid instead of Int id. Scheduled for removal in Umbraco 18.")]
     IMemberGroup? GetById(int id);
 
-    /// <summary>
-    ///     Gets a member group by its <see cref="Guid"/> key.
-    /// </summary>
-    /// <param name="id">The <see cref="Guid"/> key of the member group.</param>
-    /// <returns>The <see cref="IMemberGroup"/> if found; otherwise, <c>null</c>.</returns>
-    [Obsolete("Please use the asynchronous counterpart. Scheduled for removal in Umbraco 18.")]
-    IMemberGroup? GetById(Guid id);
-
     /// <summary>
     ///     Gets multiple member groups by their integer ids.
     /// </summary>
@@ -46,13 +38,6 @@ public interface IMemberGroupService : IService
     /// <returns>The <see cref="IMemberGroup"/> if found; otherwise, <c>null</c>.</returns>
     IMemberGroup? GetByName(string? name);
 
-    /// <summary>
-    ///     Saves a member group.
-    /// </summary>
-    /// <param name="memberGroup">The <see cref="IMemberGroup"/> to save.</param>
-    [Obsolete("Please use the respective CreateAsync/UpdateAsync for your save operations. Scheduled for removal in Umbraco 18.")]
-    void Save(IMemberGroup memberGroup);
-
     /// <summary>
     ///     Deletes a member group.
     /// </summary>
diff --git a/src/Umbraco.Core/Services/IMemberService.cs b/src/Umbraco.Core/Services/IMemberService.cs
index ac11e7e117a0..35e3a773a6cc 100644
--- a/src/Umbraco.Core/Services/IMemberService.cs
+++ b/src/Umbraco.Core/Services/IMemberService.cs
@@ -223,20 +223,6 @@ IMember CreateMemberWithIdentity(string username, string email, string name, str
     /// <returns><c>True</c> if the Member exists otherwise <c>False</c></returns>
     bool Exists(int id);
 
-    /// <summary>
-    ///     Gets a Member by the unique key
-    /// </summary>
-    /// <remarks>
-    ///     The guid key corresponds to the unique id in the database
-    ///     and the user id in the membership provider.
-    /// </remarks>
-    /// <param name="id"><see cref="Guid" /> Id</param>
-    /// <returns>
-    ///     <see cref="IMember" />
-    /// </returns>
-    [Obsolete($"Use {nameof(GetById)}. Scheduled for removal in Umbraco 18.")]
-    IMember? GetByKey(Guid id) => GetById(id);
-
     /// <summary>
     ///     Gets a Member by its integer id
     /// </summary>
diff --git a/src/Umbraco.Core/Services/IPublishableContentService.cs b/src/Umbraco.Core/Services/IPublishableContentService.cs
index c742785143dc..e817913a57f2 100644
--- a/src/Umbraco.Core/Services/IPublishableContentService.cs
+++ b/src/Umbraco.Core/Services/IPublishableContentService.cs
@@ -45,6 +45,13 @@ public interface IPublishableContentService<TContent> : IContentServiceBase<TCon
     /// <returns>The <see cref="ContentScheduleCollection" />.</returns>
     ContentScheduleCollection GetContentScheduleByContentId(Guid contentId);
 
+    /// <summary>
+    ///     Gets a dictionary of content keys and their matching content schedules.
+    /// </summary>
+    /// <param name="keys">The content keys.</param>
+    /// <returns>A dictionary with a content key and an IEnumerable of matching ContentSchedules.</returns>
+    IDictionary<Guid, IEnumerable<ContentSchedule>> GetContentSchedulesByKeys(Guid[] keys);
+
     /// <summary>
     ///     Persists publish/unpublish schedule for a content node.
     /// </summary>
diff --git a/src/Umbraco.Core/Services/IRelationService.cs b/src/Umbraco.Core/Services/IRelationService.cs
index 01fc73ae8f55..4958c4e219ec 100644
--- a/src/Umbraco.Core/Services/IRelationService.cs
+++ b/src/Umbraco.Core/Services/IRelationService.cs
@@ -305,15 +305,6 @@ public interface IRelationService : IService
     /// </returns>
     bool HasRelations(IRelationType relationType);
 
-    /// <summary>
-    ///     Checks whether any relations exists for the passed in Id and direction.
-    /// </summary>
-    /// <param name="id">Id of an object to check relations for</param>
-    /// <param name="directionFilter">Indicates whether to check for relations as parent, child or in either direction.</param>
-    /// <returns>Returns <c>True</c> if any relations exists with the given Id, otherwise <c>False</c>.</returns>
-    [Obsolete("Please use the overload taking all parameters. Scheduled for removal in Umbraco 18.")]
-    bool IsRelated(int id, RelationDirectionFilter directionFilter);
-
     /// <summary>
     ///     Checks whether any relations exists for the passed in Id and direction.
     /// </summary>
@@ -323,10 +314,7 @@ public interface IRelationService : IService
     /// <param name="excludeRelationTypeIds">A collection of relation type Ids to exclude from consideration in the relation checks.</param>
     /// <remarks>If no relation type Ids are provided in includeRelationTypeIds or excludeRelationTypeIds, all relation type Ids are considered.</remarks>
     /// <returns>Returns <c>True</c> if any relations exists with the given Id, otherwise <c>False</c>.</returns>
-    bool IsRelated(int id, RelationDirectionFilter directionFilter, int[]? includeRelationTypeIds = null, int[]? excludeRelationTypeIds = null)
-#pragma warning disable CS0618 // Type or member is obsolete
-        => IsRelated(id, directionFilter);
-#pragma warning restore CS0618 // Type or member is obsolete
+    bool IsRelated(int id, RelationDirectionFilter directionFilter, int[]? includeRelationTypeIds = null, int[]? excludeRelationTypeIds = null);
 
     /// <summary>
     ///     Checks whether two items are related
diff --git a/src/Umbraco.Core/Services/IUserGroupService.cs b/src/Umbraco.Core/Services/IUserGroupService.cs
index f4c1b90eeb4b..862c5ac9e002 100644
--- a/src/Umbraco.Core/Services/IUserGroupService.cs
+++ b/src/Umbraco.Core/Services/IUserGroupService.cs
@@ -130,11 +130,7 @@ public interface IUserGroupService
     /// <remarks>
     /// Non-admin users can only add groups they themselves belong to. Removing groups is always allowed.
     /// </remarks>
-    // TODO (V18): Remove default implementation.
-    Task<Attempt<UserGroupOperationStatus>> UpdateUserGroupsOnUsersAsync(ISet<Guid> userGroupKeys, ISet<Guid> userKeys, Guid performingUserKey)
-#pragma warning disable CS0618 // Type or member is obsolete
-        => UpdateUserGroupsOnUsersAsync(userGroupKeys, userKeys);
-#pragma warning restore CS0618 // Type or member is obsolete
+    Task<Attempt<UserGroupOperationStatus>> UpdateUserGroupsOnUsersAsync(ISet<Guid> userGroupKeys, ISet<Guid> userKeys, Guid performingUserKey);
 
     /// <summary>
     ///     Adds users to a user group.
diff --git a/src/Umbraco.Core/Services/LocalizationService.cs b/src/Umbraco.Core/Services/LocalizationService.cs
index 1c9ee55d2d52..364dcc566a08 100644
--- a/src/Umbraco.Core/Services/LocalizationService.cs
+++ b/src/Umbraco.Core/Services/LocalizationService.cs
@@ -53,32 +53,6 @@ public LocalizationService(
         _userIdKeyResolver = userIdKeyResolver;
     }
 
-    /// <summary>
-    ///     Creates and saves a new dictionary item and assigns a value to all languages if defaultValue is specified.
-    /// </summary>
-    /// <param name="key"></param>
-    /// <param name="parentId"></param>
-    /// <param name="defaultValue"></param>
-    /// <returns></returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    public IDictionaryItem CreateDictionaryItemWithIdentity(string key, Guid? parentId, string? defaultValue = null)
-    {
-        IEnumerable<IDictionaryTranslation> translations = defaultValue.IsNullOrWhiteSpace()
-            ? Array.Empty<IDictionaryTranslation>()
-            : GetAllLanguages()
-                .Select(language => new DictionaryTranslation(language, defaultValue!))
-                .ToArray();
-
-        Attempt<IDictionaryItem, DictionaryItemOperationStatus> result = _dictionaryItemService
-            .CreateAsync(new DictionaryItem(parentId, key) { Translations = translations }, Constants.Security.SuperUserKey)
-            .GetAwaiter()
-            .GetResult();
-        // mimic old service behavior
-        return result.Success || result.Status == DictionaryItemOperationStatus.CancelledByNotification
-            ? result.Result
-            : throw new ArgumentException($"Could not create a dictionary item with key: {key} under parent: {parentId}");
-    }
-
     /// <summary>
     ///     Gets a <see cref="IDictionaryItem" /> by its <see cref="int" /> id
     /// </summary>
@@ -116,17 +90,6 @@ public IDictionaryItem CreateDictionaryItemWithIdentity(string key, Guid? parent
         }
     }
 
-    /// <summary>
-    ///     Gets a collection <see cref="IDictionaryItem" /> by their <see cref="Guid" /> ids
-    /// </summary>
-    /// <param name="ids">Ids of the <see cref="IDictionaryItem" /></param>
-    /// <returns>
-    ///     A collection of <see cref="IDictionaryItem" />
-    /// </returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    public IEnumerable<IDictionaryItem> GetDictionaryItemsByIds(params Guid[] ids)
-        => _dictionaryItemService.GetManyAsync(ids).GetAwaiter().GetResult();
-
     /// <summary>
     ///     Gets a <see cref="IDictionaryItem" /> by its key
     /// </summary>
@@ -138,17 +101,6 @@ public IEnumerable<IDictionaryItem> GetDictionaryItemsByIds(params Guid[] ids)
     public IDictionaryItem? GetDictionaryItemByKey(string key)
         => _dictionaryItemService.GetAsync(key).GetAwaiter().GetResult();
 
-    /// <summary>
-    ///     Gets a collection of <see cref="IDictionaryItem" /> by their keys
-    /// </summary>
-    /// <param name="keys">Keys of the <see cref="IDictionaryItem" /></param>
-    /// <returns>
-    ///     A collection of <see cref="IDictionaryItem" />
-    /// </returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    public IEnumerable<IDictionaryItem> GetDictionaryItemsByKeys(params string[] keys)
-        => _dictionaryItemService.GetManyAsync(keys).GetAwaiter().GetResult();
-
     /// <summary>
     /// Gets a list of children for a <see cref="IDictionaryItem"/>
     /// </summary>
@@ -158,32 +110,6 @@ public IEnumerable<IDictionaryItem> GetDictionaryItemsByKeys(params string[] key
     public IEnumerable<IDictionaryItem> GetDictionaryItemChildren(Guid parentId)
         => _dictionaryItemService.GetChildrenAsync(parentId).GetAwaiter().GetResult();
 
-    /// <summary>
-    ///     Gets a list of descendants for a <see cref="IDictionaryItem" />
-    /// </summary>
-    /// <param name="parentId">Id of the parent, null will return all dictionary items</param>
-    /// <returns>An enumerable list of <see cref="IDictionaryItem" /> objects</returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    public IEnumerable<IDictionaryItem> GetDictionaryItemDescendants(Guid? parentId)
-        => _dictionaryItemService.GetDescendantsAsync(parentId).GetAwaiter().GetResult();
-
-    /// <summary>
-    /// Gets the root/top <see cref="IDictionaryItem"/> objects
-    /// </summary>
-    /// <returns>An enumerable list of <see cref="IDictionaryItem"/> objects</returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    public IEnumerable<IDictionaryItem> GetRootDictionaryItems()
-        => _dictionaryItemService.GetAtRootAsync().GetAwaiter().GetResult();
-
-    /// <summary>
-    ///     Checks if a <see cref="IDictionaryItem" /> with given key exists
-    /// </summary>
-    /// <param name="key">Key of the <see cref="IDictionaryItem" /></param>
-    /// <returns>True if a <see cref="IDictionaryItem" /> exists, otherwise false</returns>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    public bool DictionaryItemExists(string key)
-        => _dictionaryItemService.ExistsAsync(key).GetAwaiter().GetResult();
-
     /// <summary>
     ///     Saves a <see cref="IDictionaryItem" /> object
     /// </summary>
@@ -203,19 +129,6 @@ public void Save(IDictionaryItem dictionaryItem, int userId = Constants.Security
         }
     }
 
-    /// <summary>
-    ///     Deletes a <see cref="IDictionaryItem" /> object and its related translations
-    ///     as well as its children.
-    /// </summary>
-    /// <param name="dictionaryItem"><see cref="IDictionaryItem" /> to delete</param>
-    /// <param name="userId">Optional id of the user deleting the dictionary item</param>
-    [Obsolete("Please use IDictionaryItemService for dictionary item operations. Scheduled for removal in Umbraco 18.")]
-    public void Delete(IDictionaryItem dictionaryItem, int userId = Constants.Security.SuperUserId)
-    {
-        Guid currentUserKey = _userIdKeyResolver.GetAsync(userId).GetAwaiter().GetResult();
-        _dictionaryItemService.DeleteAsync(dictionaryItem.Key, currentUserKey).GetAwaiter().GetResult();
-    }
-
     /// <summary>
     ///     Gets a <see cref="Language" /> by its id
     /// </summary>
@@ -246,11 +159,6 @@ public void Delete(IDictionaryItem dictionaryItem, int userId = Constants.Securi
         return _languageService.GetAsync(isoCode).GetAwaiter().GetResult();
     }
 
-    /// <inheritdoc />
-    [Obsolete("Please use ILanguageService for language operations. Scheduled for removal in Umbraco 18.")]
-    public int? GetLanguageIdByIsoCode(string isoCode)
-        => _languageService.GetAsync(isoCode).GetAwaiter().GetResult()?.Id;
-
     /// <inheritdoc />
     [Obsolete("Please use ILanguageService for language operations. Scheduled for removal in Umbraco 18.")]
     public string GetDefaultLanguageIsoCode()
@@ -283,16 +191,4 @@ public void Save(ILanguage language, int userId = Constants.Security.SuperUserId
             throw new InvalidOperationException($"Cannot save language {language.IsoCode} with fallback {language.FallbackIsoCode}.");
         }
     }
-
-    /// <summary>
-    ///     Deletes a <see cref="ILanguage" /> by removing it (but not its usages) from the db
-    /// </summary>
-    /// <param name="language"><see cref="ILanguage" /> to delete</param>
-    /// <param name="userId">Optional id of the user deleting the language</param>
-    [Obsolete("Please use ILanguageService for language operations. Scheduled for removal in Umbraco 18.")]
-    public void Delete(ILanguage language, int userId = Constants.Security.SuperUserId)
-    {
-        Guid currentUserKey = _userIdKeyResolver.GetAsync(userId).GetAwaiter().GetResult();
-        _languageService.DeleteAsync(language.IsoCode, currentUserKey).GetAwaiter().GetResult();
-    }
 }
diff --git a/src/Umbraco.Core/Services/MemberGroupService.cs b/src/Umbraco.Core/Services/MemberGroupService.cs
index 343e94f7aa96..6789944c1aef 100644
--- a/src/Umbraco.Core/Services/MemberGroupService.cs
+++ b/src/Umbraco.Core/Services/MemberGroupService.cs
@@ -45,39 +45,9 @@ public MemberGroupService(ICoreScopeProvider provider, ILoggerFactory loggerFact
         }
     }
 
-    /// <inheritdoc />
-    public IMemberGroup? GetById(Guid id) => GetAsync(id).GetAwaiter().GetResult();
-
     /// <inheritdoc />
     public IMemberGroup? GetByName(string? name) => name is null ? null : GetByNameAsync(name).GetAwaiter().GetResult();
 
-    /// <inheritdoc />
-    public void Save(IMemberGroup memberGroup)
-    {
-        if (string.IsNullOrWhiteSpace(memberGroup.Name))
-        {
-            throw new InvalidOperationException("The name of a MemberGroup can not be empty");
-        }
-
-        EventMessages evtMsgs = EventMessagesFactory.Get();
-
-        using (ICoreScope scope = ScopeProvider.CreateCoreScope())
-        {
-            var savingNotification = new MemberGroupSavingNotification(memberGroup, evtMsgs);
-            if (scope.Notifications.PublishCancelable(savingNotification))
-            {
-                scope.Complete();
-                return;
-            }
-
-            _memberGroupRepository.Save(memberGroup);
-            scope.Complete();
-
-            scope.Notifications.Publish(
-                new MemberGroupSavedNotification(memberGroup, evtMsgs).WithStateFrom(savingNotification));
-        }
-    }
-
     /// <inheritdoc />
     public void Delete(IMemberGroup memberGroup) => DeleteAsync(memberGroup.Key).GetAwaiter().GetResult();
 
diff --git a/src/Umbraco.Core/Services/MemberTwoFactorLoginService.cs b/src/Umbraco.Core/Services/MemberTwoFactorLoginService.cs
index ede51cff56c1..2d232b98146f 100644
--- a/src/Umbraco.Core/Services/MemberTwoFactorLoginService.cs
+++ b/src/Umbraco.Core/Services/MemberTwoFactorLoginService.cs
@@ -28,7 +28,7 @@ public MemberTwoFactorLoginService(
     /// <inheritdoc cref="IMemberTwoFactorLoginService.DisableAsync" />
     public override async Task<Attempt<TwoFactorOperationStatus>> DisableAsync(Guid memberKey, string providerName)
     {
-        IMember? member = _memberService.GetByKey(memberKey);
+        IMember? member = _memberService.GetById(memberKey);
 
         if (member is null)
         {
@@ -41,7 +41,7 @@ public override async Task<Attempt<TwoFactorOperationStatus>> DisableAsync(Guid
     /// <inheritdoc cref="IMemberTwoFactorLoginService.GetProviderNamesAsync" />
     public override async Task<Attempt<IEnumerable<UserTwoFactorProviderModel>, TwoFactorOperationStatus>> GetProviderNamesAsync(Guid memberKey)
     {
-        IMember? member = _memberService.GetByKey(memberKey);
+        IMember? member = _memberService.GetById(memberKey);
 
         if (member is null)
         {
@@ -54,7 +54,7 @@ public override async Task<Attempt<IEnumerable<UserTwoFactorProviderModel>, TwoF
     /// <inheritdoc cref="IMemberTwoFactorLoginService.GetSetupInfoAsync" />
     public override async Task<Attempt<ISetupTwoFactorModel, TwoFactorOperationStatus>> GetSetupInfoAsync(Guid memberKey, string providerName)
     {
-        IMember? member = _memberService.GetByKey(memberKey);
+        IMember? member = _memberService.GetById(memberKey);
 
         if (member is null)
         {
@@ -67,7 +67,7 @@ public override async Task<Attempt<ISetupTwoFactorModel, TwoFactorOperationStatu
     /// <inheritdoc cref="IMemberTwoFactorLoginService.ValidateAndSaveAsync" />
     public override async Task<Attempt<TwoFactorOperationStatus>> ValidateAndSaveAsync(string providerName, Guid memberKey, string secret, string code)
     {
-        IMember? member = _memberService.GetByKey(memberKey);
+        IMember? member = _memberService.GetById(memberKey);
 
         if (member is null)
         {
diff --git a/src/Umbraco.Core/Services/OperationStatus/ContentTypeOperationStatus.cs b/src/Umbraco.Core/Services/OperationStatus/ContentTypeOperationStatus.cs
index 088d6ae5568f..c3fee856ab1a 100644
--- a/src/Umbraco.Core/Services/OperationStatus/ContentTypeOperationStatus.cs
+++ b/src/Umbraco.Core/Services/OperationStatus/ContentTypeOperationStatus.cs
@@ -130,4 +130,9 @@ public enum ContentTypeOperationStatus
     ///     Element types cannot vary by segment.
     /// </summary>
     InvalidSegmentVariationForElementType,
+
+    /// <summary>
+    ///     The alias of a system content type cannot be changed.
+    /// </summary>
+    SystemAliasChangeNotAllowed,
 }
diff --git a/src/Umbraco.Core/Services/OperationStatus/UserOperationStatus.cs b/src/Umbraco.Core/Services/OperationStatus/UserOperationStatus.cs
index ed8a30296ff5..6caeb3a7f4a0 100644
--- a/src/Umbraco.Core/Services/OperationStatus/UserOperationStatus.cs
+++ b/src/Umbraco.Core/Services/OperationStatus/UserOperationStatus.cs
@@ -189,5 +189,19 @@ public enum UserOperationStatus
     ///     The operation failed because the username is invalid.
     /// </summary>
     InvalidUserName,
+
+    /// <summary>
+    ///     The operation failed because the element node could not be found.
+    /// </summary>
     ElementNodeNotFound,
+
+    /// <summary>
+    ///     The operation failed because the element start node could not be found.
+    /// </summary>
+    ElementStartNodeNotFound,
+    ///     The operation failed because the application URL is not configured.
+    ///     Set <c>Umbraco:CMS:WebRouting:UmbracoApplicationUrl</c> or change
+    ///     <c>ApplicationUrlDetection</c> to <c>FirstRequest</c> or <c>EveryRequest</c>.
+    /// </summary>
+    ApplicationUrlNotConfigured,
 }
diff --git a/src/Umbraco.Core/Services/PartialViewService.cs b/src/Umbraco.Core/Services/PartialViewService.cs
index 7bca2633dad9..eab2653df0ba 100644
--- a/src/Umbraco.Core/Services/PartialViewService.cs
+++ b/src/Umbraco.Core/Services/PartialViewService.cs
@@ -27,13 +27,6 @@ public class PartialViewService : FileServiceOperationBase<IPartialViewRepositor
     private readonly PartialViewSnippetCollection _snippetCollection;
     private readonly IOptions<RuntimeSettings> _runtimeSettings;
 
-    // TODO (V18): Remove obsolete constructors and the ActivatorUtilitiesConstructor attribute.
-    // Also update UmbracoBuilder where this service is registered using:
-    //   Services.AddUnique<IPartialViewService>(sp => ActivatorUtilities.CreateInstance<PartialViewService>(sp));
-    // We do this to allow the ActivatorUtilitiesConstructor to be used (it's otherwise ignored by AddUnique).
-    // Revert it to:
-    //   Services.AddUnique<IPartialViewService, PartialViewService>();
-
     /// <summary>
     ///     Initializes a new instance of the <see cref="PartialViewService" /> class.
     /// </summary>
@@ -46,7 +39,6 @@ public class PartialViewService : FileServiceOperationBase<IPartialViewRepositor
     /// <param name="auditService">The service for audit logging.</param>
     /// <param name="snippetCollection">The collection of available partial view snippets.</param>
     /// <param name="runtimeSettings">The runtime configuration settings.</param>
-    [ActivatorUtilitiesConstructor]
     public PartialViewService(
         ICoreScopeProvider provider,
         ILoggerFactory loggerFactory,
diff --git a/src/Umbraco.Core/Services/PublishableContentServiceBase.cs b/src/Umbraco.Core/Services/PublishableContentServiceBase.cs
index 94ec69be25a6..156c394864b5 100644
--- a/src/Umbraco.Core/Services/PublishableContentServiceBase.cs
+++ b/src/Umbraco.Core/Services/PublishableContentServiceBase.cs
@@ -1,3 +1,4 @@
+using System.Collections.Immutable;
 using Microsoft.Extensions.Logging;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Exceptions;
@@ -293,6 +294,44 @@ public ContentScheduleCollection GetContentScheduleByContentId(Guid contentId)
         return GetContentScheduleByContentId(idAttempt.Result);
     }
 
+    /// <inheritdoc />
+    public IDictionary<Guid, IEnumerable<ContentSchedule>> GetContentSchedulesByKeys(Guid[] keys)
+    {
+        if (keys.Length == 0)
+        {
+            return ImmutableDictionary<Guid, IEnumerable<ContentSchedule>>.Empty;
+        }
+
+        Dictionary<int, Guid> intToKeyMap = new(keys.Length);
+        foreach (Guid key in keys)
+        {
+            Attempt<int> contentId = _idKeyMap.GetIdForKey(key, ContentObjectType);
+            if (contentId.Success is false)
+            {
+                continue;
+            }
+
+            intToKeyMap[contentId.Result] = key;
+        }
+
+        using ICoreScope scope = ScopeProvider.CreateCoreScope(autoComplete: true);
+        scope.ReadLock(ReadLockIds);
+
+        IDictionary<int, IEnumerable<ContentSchedule>> intKeyedResults =
+            _documentRepository.GetContentSchedulesByIds(intToKeyMap.Keys.ToArray());
+
+        var guidKeyedResults = new Dictionary<Guid, IEnumerable<ContentSchedule>>(intKeyedResults.Count);
+        foreach (KeyValuePair<int, IEnumerable<ContentSchedule>> entry in intKeyedResults)
+        {
+            if (intToKeyMap.TryGetValue(entry.Key, out Guid guidKey))
+            {
+                guidKeyedResults[guidKey] = entry.Value;
+            }
+        }
+
+        return guidKeyedResults;
+    }
+
     /// <inheritdoc />
     public void PersistContentSchedule(IPublishableContentBase content, ContentScheduleCollection contentSchedule)
     {
diff --git a/src/Umbraco.Core/Services/RelationService.cs b/src/Umbraco.Core/Services/RelationService.cs
index 72856948be73..4686cd29ca82 100644
--- a/src/Umbraco.Core/Services/RelationService.cs
+++ b/src/Umbraco.Core/Services/RelationService.cs
@@ -532,15 +532,6 @@ public bool HasRelations(IRelationType relationType)
     [Obsolete("No longer used in Umbraco, please the overload taking all parameters. Scheduled for removal in Umbraco 19.")]
     public bool IsRelated(int id) => IsRelated(id, RelationDirectionFilter.Any, null, null);
 
-    /// <summary>
-    /// Checks whether an entity has relations in the specified direction.
-    /// </summary>
-    /// <param name="id">The identifier of the entity.</param>
-    /// <param name="directionFilter">The direction filter to apply when checking relations.</param>
-    /// <returns><c>true</c> if the entity has relations matching the filter; otherwise, <c>false</c>.</returns>
-    [Obsolete("Please the overload taking all parameters. Scheduled for removal in Umbraco 18.")]
-    public bool IsRelated(int id, RelationDirectionFilter directionFilter) => IsRelated(id, directionFilter, null, null);
-
     /// <inheritdoc />
     public bool IsRelated(int id, RelationDirectionFilter directionFilter, int[]? includeRelationTypeIds = null, int[]? excludeRelationTypeIds = null)
     {
diff --git a/src/Umbraco.Core/Services/TemplateService.cs b/src/Umbraco.Core/Services/TemplateService.cs
index b2576d2f16bf..b3bea79cd3d8 100644
--- a/src/Umbraco.Core/Services/TemplateService.cs
+++ b/src/Umbraco.Core/Services/TemplateService.cs
@@ -23,13 +23,6 @@ public class TemplateService : RepositoryService, ITemplateService
     private readonly ITemplateContentParserService _templateContentParserService;
     private readonly IOptions<RuntimeSettings> _runtimeSettings;
 
-    // TODO (V18): Remove obsolete constructors and the ActivatorUtilitiesConstructor attribute.
-    // Also update UmbracoBuilder where this service is registered using:
-    //   Services.AddUnique<ITemplateService>(sp => ActivatorUtilities.CreateInstance<TemplateService>(sp));
-    // We do this to allow the ActivatorUtilitiesConstructor to be used (it's otherwise ignored by AddUnique).
-    // Revert it to:
-    //   Services.AddUnique<ITemplateService, TemplateService>();
-
     /// <summary>
     ///     Initializes a new instance of the <see cref="TemplateService" /> class.
     /// </summary>
diff --git a/src/Umbraco.Core/Services/UserService.cs b/src/Umbraco.Core/Services/UserService.cs
index d70a970859d3..1e0db258146e 100644
--- a/src/Umbraco.Core/Services/UserService.cs
+++ b/src/Umbraco.Core/Services/UserService.cs
@@ -905,6 +905,14 @@ private async Task<UserOperationStatus> ValidateUserCreateModel(UserCreateModel
             return Attempt.FailWithStatus<IUser?, UserOperationStatus>(UserOperationStatus.MediaStartNodeNotFound, existingUser);
         }
 
+        List<int>? startElementIds = GetIdsFromKeys(model.ElementStartNodeKeys, UmbracoObjectTypes.ElementContainer);
+
+        if (startElementIds is null || startElementIds.Count != model.ElementStartNodeKeys.Count)
+        {
+            scope.Complete();
+            return Attempt.FailWithStatus<IUser?, UserOperationStatus>(UserOperationStatus.ElementStartNodeNotFound, existingUser);
+        }
+
         if (model.HasContentRootAccess)
         {
             startContentIds.Add(Constants.System.Root);
@@ -915,6 +923,11 @@ private async Task<UserOperationStatus> ValidateUserCreateModel(UserCreateModel
             startMediaIds.Add(Constants.System.Root);
         }
 
+        if (model.HasElementRootAccess)
+        {
+            startElementIds.Add(Constants.System.Root);
+        }
+
         Attempt<string?> isAuthorized = _userEditorAuthorizationHelper.IsAuthorized(
             performingUser,
             existingUser,
@@ -939,7 +952,7 @@ private async Task<UserOperationStatus> ValidateUserCreateModel(UserCreateModel
         // TODO: This probably shouldn't live here, once we have user content start nodes as keys this can be moved to a mapper
         // Alternatively it should be a map definition, but then we need to use entity service to resolve the IDs
         // TODO: Add auditing
-        IUser updated = MapUserUpdate(model, userGroups, existingUser, startContentIds, startMediaIds);
+        IUser updated = MapUserUpdate(model, userGroups, existingUser, startContentIds, startMediaIds, startElementIds);
         UserOperationStatus saveStatus = await userStore.SaveAsync(updated);
 
         if (saveStatus is not UserOperationStatus.Success)
@@ -1005,13 +1018,15 @@ public async Task<UserOperationStatus> SetAvatarAsync(Guid userKey, Guid tempora
     /// <param name="target">The target user to update.</param>
     /// <param name="startContentIds">The content start node IDs.</param>
     /// <param name="startMediaIds">The media start node IDs.</param>
+    /// <param name="startElementIds">The element start node IDs.</param>
     /// <returns>The updated <see cref="IUser" />.</returns>
     private IUser MapUserUpdate(
         UserUpdateModel source,
         ISet<IUserGroup> sourceUserGroups,
         IUser target,
         List<int> startContentIds,
-        List<int> startMediaIds)
+        List<int> startMediaIds,
+        List<int> startElementIds)
     {
         target.Name = source.Name;
         target.Language = source.LanguageIsoCode;
@@ -1019,6 +1034,7 @@ private IUser MapUserUpdate(
         target.Username = source.UserName;
         target.StartContentIds = startContentIds.ToArray();
         target.StartMediaIds = startMediaIds.ToArray();
+        target.StartElementIds = startElementIds.ToArray();
 
         target.ClearGroups();
         foreach (IUserGroup group in sourceUserGroups)
diff --git a/src/Umbraco.Core/Webhooks/LegacyEvents/Content/LegacyContentCopiedWebhookEvent.cs b/src/Umbraco.Core/Webhooks/LegacyEvents/Content/LegacyContentCopiedWebhookEvent.cs
index 65ebf5eb24f6..592f710656a6 100644
--- a/src/Umbraco.Core/Webhooks/LegacyEvents/Content/LegacyContentCopiedWebhookEvent.cs
+++ b/src/Umbraco.Core/Webhooks/LegacyEvents/Content/LegacyContentCopiedWebhookEvent.cs
@@ -42,7 +42,7 @@ public override object ConvertNotificationToRequestPayload(ContentCopiedNotifica
         {
             notification.Copy,
             notification.Original,
-            notification.ParentId,
+            notification.ParentKey,
             notification.RelateToOriginal
         };
     }
diff --git a/src/Umbraco.Examine.Lucene/DeliveryApiContentIndex.cs b/src/Umbraco.Examine.Lucene/DeliveryApiContentIndex.cs
index 87a49cf613a3..8d7d6ef887b1 100644
--- a/src/Umbraco.Examine.Lucene/DeliveryApiContentIndex.cs
+++ b/src/Umbraco.Examine.Lucene/DeliveryApiContentIndex.cs
@@ -20,6 +20,9 @@ public class DeliveryApiContentIndex : UmbracoExamineIndex
     // The special path and icon value transformations are not needed in this case
     protected override bool ApplySpecialValueTransformations => false;
 
+    /// <inheritdoc />
+    public override string UniqueKeyFieldName => UmbracoExamineFieldNames.DeliveryApiContentIndex.ItemId;
+
     public DeliveryApiContentIndex(
         ILoggerFactory loggerFactory,
         string name,
diff --git a/src/Umbraco.Examine.Lucene/UmbracoExamineIndex.cs b/src/Umbraco.Examine.Lucene/UmbracoExamineIndex.cs
index f1a26b7bd944..37ad6e795ce3 100644
--- a/src/Umbraco.Examine.Lucene/UmbracoExamineIndex.cs
+++ b/src/Umbraco.Examine.Lucene/UmbracoExamineIndex.cs
@@ -55,6 +55,9 @@ protected UmbracoExamineIndex(
 
     public bool SupportProtectedContent { get; protected set; } = true;
 
+    /// <inheritdoc />
+    public virtual string UniqueKeyFieldName => UmbracoExamineFieldNames.NodeKeyFieldName;
+
     /// <summary>
     ///     override to check if we can actually initialize.
     /// </summary>
diff --git a/src/Umbraco.Infrastructure/Cache/FullDataSetRepositoryCachePolicy.cs b/src/Umbraco.Infrastructure/Cache/FullDataSetRepositoryCachePolicy.cs
index 2ac1af1e181f..3dbd5f2e3ad5 100644
--- a/src/Umbraco.Infrastructure/Cache/FullDataSetRepositoryCachePolicy.cs
+++ b/src/Umbraco.Infrastructure/Cache/FullDataSetRepositoryCachePolicy.cs
@@ -191,6 +191,58 @@ public override TEntity[] GetAll(TId[]? ids, Func<TId[], IEnumerable<TEntity>?>
     /// <inheritdoc />
     public override void ClearAll() => Cache.Clear(GetEntityTypeCacheKey());
 
+    /// <summary>
+    /// Gets a single entity matching a predicate from cache, cloning only the match.
+    /// If cache is empty, populates it first via <paramref name="performGetAll"/>.
+    /// </summary>
+    /// <param name="predicate">The predicate to match against cached entities.</param>
+    /// <param name="performGetAll">The repository PerformGetAll method, used to populate the cache on a miss.</param>
+    /// <returns>A deep-cloned copy of the matching entity, or null if not found.</returns>
+    internal TEntity? FindCached(Func<TEntity, bool> predicate, Func<TId[], IEnumerable<TEntity>?> performGetAll)
+    {
+        EnsureCacheIsSynced();
+
+        IEnumerable<TEntity> all = GetAllCached(performGetAll);
+        TEntity? entity = all.FirstOrDefault(predicate);
+
+        // See note in InsertEntities - what we get here is the original
+        // cached entity, not a clone, so we need to manually ensure it is deep-cloned.
+        return (TEntity?)entity?.DeepClone();
+    }
+
+    /// <summary>
+    /// Gets all entities matching a predicate from cache, cloning only the matches.
+    /// If cache is empty, populates it first via <paramref name="performGetAll"/>.
+    /// </summary>
+    /// <param name="predicate">The predicate to match against cached entities.</param>
+    /// <param name="performGetAll">The repository PerformGetAll method, used to populate the cache on a miss.</param>
+    /// <returns>An array of deep-cloned copies of matching entities.</returns>
+    internal TEntity[] FindAllCached(Func<TEntity, bool> predicate, Func<TId[], IEnumerable<TEntity>?> performGetAll)
+    {
+        EnsureCacheIsSynced();
+
+        IEnumerable<TEntity> all = GetAllCached(performGetAll);
+
+        // See note in InsertEntities - what we get here are the original
+        // cached entities, not clones, so we need to manually ensure they are deep-cloned.
+        return all.Where(predicate).Select(x => (TEntity)x.DeepClone()).ToArray();
+    }
+
+    /// <summary>
+    /// Checks whether any cached entity matches the predicate, without cloning.
+    /// If cache is empty, populates it first via <paramref name="performGetAll"/>.
+    /// </summary>
+    /// <param name="predicate">The predicate to match against cached entities.</param>
+    /// <param name="performGetAll">The repository PerformGetAll method, used to populate the cache on a miss.</param>
+    /// <returns>True if any entity matches the predicate; otherwise false.</returns>
+    internal bool ExistsCached(Func<TEntity, bool> predicate, Func<TId[], IEnumerable<TEntity>?> performGetAll)
+    {
+        EnsureCacheIsSynced();
+
+        IEnumerable<TEntity> all = GetAllCached(performGetAll);
+        return all.Any(predicate);
+    }
+
     /// <summary>
     /// Gets all cached entities, or retrieves them from the repository if not cached.
     /// </summary>
diff --git a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.CoreServices.cs b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.CoreServices.cs
index e6f39e1aeeb5..8135412d955f 100644
--- a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.CoreServices.cs
+++ b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.CoreServices.cs
@@ -1,5 +1,6 @@
 using Examine;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Umbraco.Cms.Core;
@@ -48,6 +49,7 @@
 using Umbraco.Cms.Infrastructure.Mail;
 using Umbraco.Cms.Infrastructure.Mail.Interfaces;
 using Umbraco.Cms.Infrastructure.Manifest;
+using Umbraco.Cms.Infrastructure.Media;
 using Umbraco.Cms.Infrastructure.Migrations;
 using Umbraco.Cms.Infrastructure.Migrations.Install;
 using Umbraco.Cms.Infrastructure.Persistence;
@@ -63,7 +65,6 @@
 using Umbraco.Cms.Infrastructure.Serialization;
 using Umbraco.Cms.Infrastructure.Services.Implement;
 using Umbraco.Extensions;
-using Microsoft.Extensions.DependencyInjection.Extensions;
 using IScopeProvider = Umbraco.Cms.Infrastructure.Scoping.IScopeProvider;
 
 namespace Umbraco.Cms.Infrastructure.DependencyInjection;
@@ -229,6 +230,7 @@ public static IUmbracoBuilder AddCoreInitialServices(this IUmbracoBuilder builde
 
         builder.Services.AddSingleton<UploadAutoFillProperties>();
         builder.Services.AddSingleton<IImageDimensionExtractor, NoopImageDimensionExtractor>();
+        builder.Services.AddSingleton<ISvgDimensionExtractor, SvgDimensionExtractor>();
         builder.Services.AddSingleton<IImageUrlGenerator, NoopImageUrlGenerator>();
 
         builder.Services.AddSingleton<ICronTabParser, NCronTabParser>();
@@ -414,6 +416,7 @@ public static IUmbracoBuilder AddCoreNotifications(this IUmbracoBuilder builder)
             .AddNotificationHandler<MediaMovedNotification, FileUploadContentDeletedNotificationHandler>()
             .AddNotificationHandler<MemberDeletedNotification, FileUploadContentDeletedNotificationHandler>()
             .AddNotificationHandler<MediaSavingNotification, FileUploadMediaSavingNotificationHandler>()
+            .AddNotificationHandler<MediaSavingNotification, SvgFileUploadMediaSavingNotificationHandler>()
             .AddNotificationHandler<ContentCopiedNotification, ImageCropperPropertyEditor>()
             .AddNotificationHandler<ContentDeletedNotification, ImageCropperPropertyEditor>()
             .AddNotificationHandler<MediaDeletedNotification, ImageCropperPropertyEditor>()
diff --git a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Database.cs b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Database.cs
index 3ed6f642a07e..2a9423ef2357 100644
--- a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Database.cs
+++ b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Database.cs
@@ -16,7 +16,7 @@ public static partial class UmbracoBuilderExtensions
 {
     internal static IUmbracoBuilder AddDatabase(this IUmbracoBuilder builder)
     {
-        builder.Services.AddSingleton<IEFCoreMigrationExecutor, EfCoreMigrationExecutor>();
+        builder.Services.AddSingleton<IEFCoreMigrationExecutor, EFCoreMigrationExecutor>();
 
         builder.AddNotificationAsyncHandler<DatabaseSchemaAndDataCreatedNotification, EFCoreCreateTablesNotificationHandler>();
         builder.AddNotificationAsyncHandler<UnattendedInstallNotification, EFCoreCreateTablesNotificationHandler>();
diff --git a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Repositories.cs b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Repositories.cs
index 4455124e668a..916f8e403a78 100644
--- a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Repositories.cs
+++ b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Repositories.cs
@@ -47,7 +47,7 @@ internal static IUmbracoBuilder AddRepositories(this IUmbracoBuilder builder)
         builder.Services.AddUnique<IMediaTypeContainerRepository, MediaTypeContainerRepository>();
         builder.Services.AddUnique<IMediaTypeRepository, MediaTypeRepository>();
         builder.Services.AddUnique<IMemberGroupRepository, MemberGroupRepository>();
-        builder.Services.AddUnique<IMemberRepository, MemberRepository>();
+        builder.Services.AddUnique<IMemberRepository>(sp => ActivatorUtilities.CreateInstance<MemberRepository>(sp));
         builder.Services.AddUnique<IMemberTypeContainerRepository, MemberTypeContainerRepository>();
         builder.Services.AddUnique<IMemberTypeRepository, MemberTypeRepository>();
         builder.Services.AddUnique<INotificationsRepository, NotificationsRepository>();
diff --git a/src/Umbraco.Infrastructure/Examine/ContentValueSetBuilder.cs b/src/Umbraco.Infrastructure/Examine/ContentValueSetBuilder.cs
index dfaec890f86a..abced5febe30 100644
--- a/src/Umbraco.Infrastructure/Examine/ContentValueSetBuilder.cs
+++ b/src/Umbraco.Infrastructure/Examine/ContentValueSetBuilder.cs
@@ -102,7 +102,9 @@ private IEnumerable<ValueSet> GetValueSetsEnumerable(IContent[] content, Diction
         {
             var isVariant = c.ContentType.VariesByCulture();
 
-            var urlValue = _documentUrlService.GetUrlSegment(c.Key, defaultCulture, false); // Always add invariant urlName
+            var urlValue = _documentUrlService.IsInitialized
+                ? _documentUrlService.GetUrlSegment(c.Key, defaultCulture, false)
+                : c.GetUrlSegment(_shortStringHelper, _urlSegmentProviders, defaultCulture); // Fallback when DocumentUrlService is not yet initialized (e.g. during upgrade)
             var values = new Dictionary<string, IEnumerable<object?>>
             {
                 { "icon", c.ContentType.Icon?.Yield() ?? Enumerable.Empty<string>() },
@@ -146,7 +148,9 @@ private IEnumerable<ValueSet> GetValueSetsEnumerable(IContent[] content, Diction
 
                 foreach (var culture in c.AvailableCultures)
                 {
-                    var variantUrl = c.GetUrlSegment(_shortStringHelper, _urlSegmentProviders, culture);
+                    var variantUrl = _documentUrlService.IsInitialized
+                        ? _documentUrlService.GetUrlSegment(c.Key, culture, false)
+                        : c.GetUrlSegment(_shortStringHelper, _urlSegmentProviders, culture);
                     var lowerCulture = culture.ToLowerInvariant();
                     values[$"urlName_{lowerCulture}"] = variantUrl?.Yield() ?? Enumerable.Empty<string>();
                     values[$"nodeName_{lowerCulture}"] = (PublishedValuesOnly
diff --git a/src/Umbraco.Infrastructure/Examine/IUmbracoIndex.cs b/src/Umbraco.Infrastructure/Examine/IUmbracoIndex.cs
index 0091618ec047..4cff051688dd 100644
--- a/src/Umbraco.Infrastructure/Examine/IUmbracoIndex.cs
+++ b/src/Umbraco.Infrastructure/Examine/IUmbracoIndex.cs
@@ -29,4 +29,10 @@ public interface IUmbracoIndex : IIndex, IIndexStats
     ///     To retain backwards compatability, the default value is true
     /// </remarks>
     bool SupportProtectedContent { get; }
+
+    /// <summary>
+    ///     The name of the index field that contains the unique entity key (GUID).
+    ///     Used by the backoffice Examine dashboard to construct edit links for search results.
+    /// </summary>
+    string UniqueKeyFieldName => UmbracoExamineFieldNames.NodeKeyFieldName;
 }
diff --git a/src/Umbraco.Infrastructure/Examine/UmbracoExamineFieldNames.cs b/src/Umbraco.Infrastructure/Examine/UmbracoExamineFieldNames.cs
index 81d48cd720c8..92cdefcf645f 100644
--- a/src/Umbraco.Infrastructure/Examine/UmbracoExamineFieldNames.cs
+++ b/src/Umbraco.Infrastructure/Examine/UmbracoExamineFieldNames.cs
@@ -63,5 +63,10 @@ public static class DeliveryApiContentIndex
         ///     The allowed members and member roles (for protected content)
         /// </summary>
         public const string ProtectedAccess = "protectedAccess";
+
+        /// <summary>
+        ///     The content key (GUID), used as the unique entity identifier for this index
+        /// </summary>
+        public const string ItemId = "itemId";
     }
 }
diff --git a/src/Umbraco.Infrastructure/HostedServices/RecurringHostedServiceBase.cs b/src/Umbraco.Infrastructure/HostedServices/RecurringHostedServiceBase.cs
index b616e824471e..e6d73c96ae72 100644
--- a/src/Umbraco.Infrastructure/HostedServices/RecurringHostedServiceBase.cs
+++ b/src/Umbraco.Infrastructure/HostedServices/RecurringHostedServiceBase.cs
@@ -1,6 +1,7 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
+using System.Diagnostics;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Umbraco.Cms.Core;
@@ -131,6 +132,7 @@ public virtual Task StopAsync(CancellationToken cancellationToken)
     /// <param name="state">The task state.</param>
     public virtual async void ExecuteAsync(object? state)
     {
+        var sw = Stopwatch.StartNew();
         try
         {
             // First, stop the timer, we do not want tasks to execute in parallel
@@ -149,9 +151,14 @@ public virtual async void ExecuteAsync(object? state)
         }
         finally
         {
-            // Resume now that the task is complete - Note we use period in both because we don't want to execute again after the delay.
-            // So first execution is after _delay, and the we wait _period between each
-            _timer?.Change(_period, _period);
+            sw.Stop();
+
+            // If the service has been stopped, _period is set to InfiniteTimeSpan in StopAsync.
+            // Preserve it to keep the timer disabled.
+            TimeSpan remaining = _period == Timeout.InfiniteTimeSpan
+                ? Timeout.InfiniteTimeSpan
+                : ComputeNextDelay(_period, sw.Elapsed);
+            _timer?.Change(remaining, _period);
         }
     }
 
@@ -163,7 +170,29 @@ public virtual async void ExecuteAsync(object? state)
     public abstract Task PerformExecuteAsync(object? state);
 
     /// <summary>
-    ///     Change the period between operations.
+    /// Computes the delay before the next execution, subtracting the elapsed execution time from the period to prevent drift.
+    /// Clamps to <see cref="TimeSpan.Zero" /> if execution exceeded the period.
+    /// </summary>
+    /// <param name="period">The configured period between executions.</param>
+    /// <param name="elapsed">The elapsed time of the current execution.</param>
+    /// <returns>
+    /// The remaining time before the next execution should start.
+    /// </returns>
+    /// <remarks>
+    /// Internal to expose for unit tests.
+    /// </remarks>
+    internal static TimeSpan ComputeNextDelay(TimeSpan period, TimeSpan elapsed)
+    {
+        TimeSpan remaining = period - elapsed;
+
+        // A negative period (e.g. Timeout.InfiniteTimeSpan = -1ms, set by StopAsync) will always produce a
+        // negative remaining value. The caller in ExecuteAsync guards against this by checking for InfiniteTimeSpan
+        // before calling this method, to avoid scheduling an extra execution after stop.
+        return remaining < TimeSpan.Zero ? TimeSpan.Zero : remaining;
+    }
+
+    /// <summary>
+    /// Change the period between operations.
     /// </summary>
     /// <param name="newPeriod">The new period between tasks</param>
     protected void ChangePeriod(TimeSpan newPeriod) => _period = newPeriod;
diff --git a/src/Umbraco.Infrastructure/Mail/BasicSmtpEmailSenderClient.cs b/src/Umbraco.Infrastructure/Mail/BasicSmtpEmailSenderClient.cs
index 03687f6be832..f7eb6e3466f0 100644
--- a/src/Umbraco.Infrastructure/Mail/BasicSmtpEmailSenderClient.cs
+++ b/src/Umbraco.Infrastructure/Mail/BasicSmtpEmailSenderClient.cs
@@ -21,6 +21,7 @@ public BasicSmtpEmailSenderClient(IOptionsMonitor<GlobalSettings> globalSettings
             => _globalSettings = globalSettings.CurrentValue;
 
         /// <inheritdoc />
+        [Obsolete("Please use the overload taking all parameters. Scheduled for removal in Umbraco 20.")]
         public async Task SendAsync(EmailMessage message)
             => await SendAsync(message, null);
 
diff --git a/src/Umbraco.Infrastructure/Mail/Interfaces/IEmailSenderClient.cs b/src/Umbraco.Infrastructure/Mail/Interfaces/IEmailSenderClient.cs
index 900ffd86759a..b810bc3471bd 100644
--- a/src/Umbraco.Infrastructure/Mail/Interfaces/IEmailSenderClient.cs
+++ b/src/Umbraco.Infrastructure/Mail/Interfaces/IEmailSenderClient.cs
@@ -7,23 +7,12 @@ namespace Umbraco.Cms.Infrastructure.Mail.Interfaces
     /// </summary>
     public interface IEmailSenderClient
     {
-        /// <summary>
-        /// Sends the email message.
-        /// </summary>
-        /// <param name="message">The <see cref="EmailMessage"/> to send.</param>
-        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
-        [Obsolete("Please use the overload taking all parameters. Scheduled for removal in Umbraco 18.")]
-        public Task SendAsync(EmailMessage message);
-
         /// <summary>
         /// Sends the email message with an expiration date.
         /// </summary>
         /// <param name="message">The <see cref="EmailMessage"/> to send.</param>
         /// <param name="expires">An optional time for expiry.</param>
         /// <returns>A <see cref="Task"/> representing the asynchronous send operation.</returns>
-        public Task SendAsync(EmailMessage message, TimeSpan? expires)
-#pragma warning disable CS0618 // Type or member is obsolete
-            => SendAsync(message);
-#pragma warning restore CS0618 // Type or member is obsolete
+        public Task SendAsync(EmailMessage message, TimeSpan? expires);
     }
 }
diff --git a/src/Umbraco.Infrastructure/Media/SvgDimensionExtractor.cs b/src/Umbraco.Infrastructure/Media/SvgDimensionExtractor.cs
new file mode 100644
index 000000000000..6d452deb4e5e
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Media/SvgDimensionExtractor.cs
@@ -0,0 +1,164 @@
+using System.Drawing;
+using System.Globalization;
+using System.Xml;
+using System.Xml.Linq;
+using Microsoft.Extensions.Logging;
+using Umbraco.Cms.Core.Media;
+
+namespace Umbraco.Cms.Infrastructure.Media;
+
+/// <inheritdoc />
+public class SvgDimensionExtractor : ISvgDimensionExtractor
+{
+    private readonly ILogger<SvgDimensionExtractor> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SvgDimensionExtractor"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    public SvgDimensionExtractor(ILogger<SvgDimensionExtractor> logger)
+        => _logger = logger;
+
+    /// <inheritdoc />
+    public Size? GetDimensions(Stream stream)
+    {
+        if (stream.CanRead is false)
+        {
+            return null;
+        }
+
+        long? originalPosition = null;
+
+        if (stream.CanSeek)
+        {
+            originalPosition = stream.Position;
+            stream.Position = 0;
+        }
+
+        try
+        {
+            return ReadDimensions(stream);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to extract dimensions from SVG stream.");
+            return null;
+        }
+        finally
+        {
+            if (originalPosition.HasValue)
+            {
+                stream.Position = originalPosition.Value;
+            }
+        }
+    }
+
+    private static Size? ReadDimensions(Stream stream)
+    {
+        var settings = new XmlReaderSettings
+        {
+            DtdProcessing = DtdProcessing.Prohibit,
+            XmlResolver = null,
+        };
+        using var reader = XmlReader.Create(stream, settings);
+        var document = XDocument.Load(reader);
+
+        XElement? root = document.Root;
+
+        if (root is null)
+        {
+            return null;
+        }
+
+        var widthAttributeValue = root.Attribute("width")?.Value;
+        var heightAttributeValue = root.Attribute("height")?.Value;
+
+        Size? size = null;
+
+        if (widthAttributeValue is not null && heightAttributeValue is not null)
+        {
+            size = ParseWidthHeightAttributes(widthAttributeValue, heightAttributeValue);
+        }
+
+        // Fall back to viewbox.
+        size ??= ParseViewBox(root);
+
+        return size;
+    }
+
+    private static Size? ParseViewBox(XElement root)
+    {
+        var viewBox = root.Attribute("viewBox")?.Value;
+
+        if (string.IsNullOrWhiteSpace(viewBox))
+        {
+            return null;
+        }
+
+        var parts = viewBox.Split([' ', ',', '\t', '\r', '\n'], StringSplitOptions.RemoveEmptyEntries);
+
+        if (parts.Length != 4)
+        {
+            return null;
+        }
+
+        if (double.TryParse(parts[2], NumberStyles.Float, CultureInfo.InvariantCulture, out var width) is false)
+        {
+            return null;
+        }
+
+        if (double.TryParse(parts[3], NumberStyles.Float, CultureInfo.InvariantCulture, out var height) is false)
+        {
+            return null;
+        }
+
+        if (width < 0 || height < 0)
+        {
+            return null;
+        }
+
+        return new Size(
+            (int)Math.Round(width),
+            (int)Math.Round(height));
+    }
+
+    private static Size? ParseWidthHeightAttributes(string widthAttributeValue, string heightAttributeValue)
+    {
+        if (TryExtractNumericFromValue(widthAttributeValue, out var widthValue)
+            && TryExtractNumericFromValue(heightAttributeValue, out var heightValue))
+        {
+            return new Size(widthValue, heightValue);
+        }
+
+        return null;
+    }
+
+    /// <summary>
+    /// Extract a "pixel" value from the width / height attributes.
+    /// </summary>
+    private static bool TryExtractNumericFromValue(string attributeValue, out int value)
+    {
+        if (int.TryParse(attributeValue, out int onlyNumbersValue) && onlyNumbersValue > 0)
+        {
+            value = onlyNumbersValue;
+            return true;
+        }
+
+        value = 0;
+
+        var input = attributeValue.Trim();
+
+        if (input.EndsWith("px", StringComparison.OrdinalIgnoreCase))
+        {
+            input = input[..^2].Trim();
+        }
+
+        if (int.TryParse(input, out var numericValue) && numericValue > 0)
+        {
+            value = numericValue;
+            return true;
+        }
+
+        return false;
+    }
+}
diff --git a/src/Umbraco.Infrastructure/Migrations/EFCoreMigration.cs b/src/Umbraco.Infrastructure/Migrations/EFCoreMigration.cs
index de3d2ab8f365..7442b918bc7e 100644
--- a/src/Umbraco.Infrastructure/Migrations/EFCoreMigration.cs
+++ b/src/Umbraco.Infrastructure/Migrations/EFCoreMigration.cs
@@ -14,4 +14,5 @@ public enum EFCoreMigration
     AddKeyValueDto = 6,
     SqliteCollation = 7,
     AddLanguageDto = 8,
+    AddDomainDto = 9,
 }
diff --git a/src/Umbraco.Infrastructure/Migrations/Install/DatabaseDataCreator.cs b/src/Umbraco.Infrastructure/Migrations/Install/DatabaseDataCreator.cs
index 47517dea5b10..e6692c2e4bcd 100644
--- a/src/Umbraco.Infrastructure/Migrations/Install/DatabaseDataCreator.cs
+++ b/src/Umbraco.Infrastructure/Migrations/Install/DatabaseDataCreator.cs
@@ -2051,6 +2051,44 @@ private void CreatePropertyTypeData()
                     Description = null,
                     Variations = (byte)ContentVariation.Nothing,
                 });
+            _database.Insert(
+                Constants.DatabaseSchema.Tables.PropertyType,
+                "id",
+                false,
+                new PropertyTypeDto
+                {
+                    Id = 53,
+                    UniqueId = new Guid("5BC7E468-C53E-41A6-A522-2723F3B94514"),
+                    DataTypeId = Constants.DataTypes.LabelPixels,
+                    ContentTypeId = 1037,
+                    PropertyTypeGroupId = 55,
+                    Alias = Constants.Conventions.Media.Width,
+                    Name = "Width",
+                    SortOrder = 0,
+                    Mandatory = false,
+                    ValidationRegExp = null,
+                    Description = null,
+                    Variations = (byte)ContentVariation.Nothing,
+                });
+            _database.Insert(
+                Constants.DatabaseSchema.Tables.PropertyType,
+                "id",
+                false,
+                new PropertyTypeDto
+                {
+                    Id = 54,
+                    UniqueId = new Guid("9E4C2B59-6BC6-4648-BB71-B0F45DDBC274"),
+                    DataTypeId = Constants.DataTypes.LabelPixels,
+                    ContentTypeId = 1037,
+                    PropertyTypeGroupId = 55,
+                    Alias = Constants.Conventions.Media.Height,
+                    Name = "Height",
+                    SortOrder = 0,
+                    Mandatory = false,
+                    ValidationRegExp = null,
+                    Description = null,
+                    Variations = (byte)ContentVariation.Nothing,
+                });
         }
 
         // Membership property types.
@@ -2237,7 +2275,7 @@ string GridCollectionView(string collectionViewType) =>
                     EditorAlias = Constants.PropertyEditors.Aliases.RichText,
                     EditorUiAlias = "Umb.PropertyEditorUi.Tiptap",
                     DbType = "Ntext",
-                    Configuration = "{\"extensions\": [\"Umb.Tiptap.RichTextEssentials\", \"Umb.Tiptap.Anchor\", \"Umb.Tiptap.Block\", \"Umb.Tiptap.Blockquote\", \"Umb.Tiptap.Bold\", \"Umb.Tiptap.BulletList\", \"Umb.Tiptap.CodeBlock\", \"Umb.Tiptap.Embed\", \"Umb.Tiptap.Figure\", \"Umb.Tiptap.Heading\", \"Umb.Tiptap.HorizontalRule\", \"Umb.Tiptap.HtmlAttributeClass\", \"Umb.Tiptap.HtmlAttributeDataset\", \"Umb.Tiptap.HtmlAttributeId\", \"Umb.Tiptap.HtmlAttributeStyle\", \"Umb.Tiptap.HtmlTagDiv\", \"Umb.Tiptap.HtmlTagSpan\", \"Umb.Tiptap.Image\", \"Umb.Tiptap.Italic\", \"Umb.Tiptap.Link\", \"Umb.Tiptap.MediaUpload\", \"Umb.Tiptap.OrderedList\", \"Umb.Tiptap.Strike\", \"Umb.Tiptap.Subscript\", \"Umb.Tiptap.Superscript\", \"Umb.Tiptap.Table\", \"Umb.Tiptap.TextAlign\", \"Umb.Tiptap.TextDirection\", \"Umb.Tiptap.TextIndent\", \"Umb.Tiptap.TrailingNode\", \"Umb.Tiptap.Underline\"], \"maxImageSize\": 500, \"overlaySize\": \"medium\", \"toolbar\": [[[\"Umb.Tiptap.Toolbar.SourceEditor\"], [\"Umb.Tiptap.Toolbar.Bold\", \"Umb.Tiptap.Toolbar.Italic\", \"Umb.Tiptap.Toolbar.Underline\"], [\"Umb.Tiptap.Toolbar.TextAlignLeft\", \"Umb.Tiptap.Toolbar.TextAlignCenter\", \"Umb.Tiptap.Toolbar.TextAlignRight\"], [\"Umb.Tiptap.Toolbar.BulletList\", \"Umb.Tiptap.Toolbar.OrderedList\"], [\"Umb.Tiptap.Toolbar.Blockquote\", \"Umb.Tiptap.Toolbar.HorizontalRule\"], [\"Umb.Tiptap.Toolbar.Link\", \"Umb.Tiptap.Toolbar.Unlink\"], [\"Umb.Tiptap.Toolbar.MediaPicker\", \"Umb.Tiptap.Toolbar.EmbeddedMedia\"]]]}",
+                    Configuration = "{\"extensions\": [\"Umb.Tiptap.RichTextEssentials\", \"Umb.Tiptap.Anchor\", \"Umb.Tiptap.Block\", \"Umb.Tiptap.Blockquote\", \"Umb.Tiptap.Bold\", \"Umb.Tiptap.BulletList\", \"Umb.Tiptap.CodeBlock\", \"Umb.Tiptap.Embed\", \"Umb.Tiptap.Figure\", \"Umb.Tiptap.Heading\", \"Umb.Tiptap.HorizontalRule\", \"Umb.Tiptap.HtmlAttributeClass\", \"Umb.Tiptap.HtmlAttributeDataset\", \"Umb.Tiptap.HtmlAttributeId\", \"Umb.Tiptap.HtmlAttributeStyle\", \"Umb.Tiptap.HtmlTagDiv\", \"Umb.Tiptap.HtmlTagSpan\", \"Umb.Tiptap.Image\", \"Umb.Tiptap.Italic\", \"Umb.Tiptap.Link\", \"Umb.Tiptap.MediaUpload\", \"Umb.Tiptap.OrderedList\", \"Umb.Tiptap.Strike\", \"Umb.Tiptap.Subscript\", \"Umb.Tiptap.Superscript\", \"Umb.Tiptap.Table\", \"Umb.Tiptap.TextAlign\", \"Umb.Tiptap.TextDirection\", \"Umb.Tiptap.TextIndent\", \"Umb.Tiptap.TrailingNode\", \"Umb.Tiptap.Underline\"], \"maxImageSize\": 500, \"overlaySize\": \"medium\", \"toolbar\": [[[\"Umb.Tiptap.Toolbar.SourceEditor\"], [\"Umb.Tiptap.Toolbar.Bold\", \"Umb.Tiptap.Toolbar.Italic\", \"Umb.Tiptap.Toolbar.Underline\"], [\"Umb.Tiptap.Toolbar.TextAlignLeft\", \"Umb.Tiptap.Toolbar.TextAlignCenter\", \"Umb.Tiptap.Toolbar.TextAlignRight\"], [\"Umb.Tiptap.Toolbar.BulletList\", \"Umb.Tiptap.Toolbar.OrderedList\"], [\"Umb.Tiptap.Toolbar.Blockquote\", \"Umb.Tiptap.Toolbar.HorizontalRule\"], [\"Umb.Tiptap.Toolbar.Link\", \"Umb.Tiptap.Toolbar.Unlink\"], [\"Umb.Tiptap.Toolbar.MediaPicker\", \"Umb.Tiptap.Toolbar.EmbeddedMedia\"]]], \"allowedMediaTypes\": \"" + Constants.MediaTypes.Guids.Image + "," + Constants.MediaTypes.Guids.Svg + "\"}",
                 });
         }
 
diff --git a/src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs b/src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs
index 6c67e84e0d14..e1e77f177af0 100644
--- a/src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs
+++ b/src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs
@@ -167,10 +167,13 @@ protected virtual void DefinePlan()
         To<V_17_3_0.AddSortableValueToPropertyData>("{9DBDB5CD-8679-4BB0-BF83-E8D508073CE0}");
         To<V_17_3_0.PopulateSortableValueForDatePropertyData>("{6748CB56-CC16-49F0-BA91-B8ECE31BF456}");
 
+        // To 17.4.0
+        To<V_17_4_0.AddContentVersionDateIndex>("{D4E5F6A7-B8C9-4D0E-A1F2-3B4C5D6E7F80}");
+        To<V_17_4_0.AddDimensionsToSvg>("{72970B86-59D8-403C-B322-FFF43F9DB199}");
 
         // To 18.0.0
         // TODO (V18): Enable on 18 branch
-        //// To<V_18_0_0.MigrateSingleBlockList>("{74332C49-B279-4945-8943-F8F00B1F5949}");
+        ////To<V_18_0_0.MigrateSingleBlockList>("{74332C49-B279-4945-8943-F8F00B1F5949}");
         To<V_18_0_0.AddElements>("{E51033DE-B4F9-45F3-87B3-0E774B2939C2}");
         To<V_18_0_0.AddAllowedInLibraryToContentType>("{31C0D92A-49DD-47EC-B2A7-932A58FF224E}");
         To<V_18_0_0.AddWebhookDto>("{F3CC0076-0692-41E5-9B2B-C58D46E556D4}");
@@ -179,5 +182,6 @@ protected virtual void DefinePlan()
         To<V_18_0_0.AddSqliteCollation>("{E4F5A6B7-C8D9-4E0F-A1B2-C3D4E5F6A7B8}");
         To<V_18_0_0.AddLanguageKeyColumn>("{A1B2C3D4-E5F6-7890-ABCD-EF1234567890}");
         To<V_18_0_0.AddLanguageDto>("{9880258E-834C-452D-A915-400D03BF9C41}");
+        To<V_18_0_0.AddDomainKeyColumn>("{B7E4F2A1-3C5D-4E6F-8A9B-0C1D2E3F4A5B}");
     }
 }
diff --git a/src/Umbraco.Infrastructure/Migrations/Upgrade/V_17_3_0/RetrustForeignKeyAndCheckConstraints.cs b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_17_3_0/RetrustForeignKeyAndCheckConstraints.cs
index ce6d8109d7ae..3039e2ebf1bd 100644
--- a/src/Umbraco.Infrastructure/Migrations/Upgrade/V_17_3_0/RetrustForeignKeyAndCheckConstraints.cs
+++ b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_17_3_0/RetrustForeignKeyAndCheckConstraints.cs
@@ -78,7 +78,9 @@ FROM sys.check_constraints cc
             // Use T-SQL TRY...CATCH to handle errors at the SQL level. This prevents a constraint
             // validation failure from dooming the .NET SqlTransaction, which would cause all
             // subsequent operations to fail with "This SqlTransaction has completed".
-            var sql = $@"
+            // Leading semicolon prevents NPoco's auto-select from prepending
+            // "SELECT ... FROM []" based on the empty [TableName("")] attribute.
+            var sql = $@";
 BEGIN TRY
     ALTER TABLE [{constraint.SchemaName}].[{constraint.TableName}] WITH CHECK CHECK CONSTRAINT [{constraint.ConstraintName}];
     SELECT CAST(1 AS BIT) AS Success, NULL AS ErrorMessage;
diff --git a/src/Umbraco.Infrastructure/Migrations/Upgrade/V_17_4_0/AddContentVersionDateIndex.cs b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_17_4_0/AddContentVersionDateIndex.cs
new file mode 100644
index 000000000000..9c70cd06ad3d
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_17_4_0/AddContentVersionDateIndex.cs
@@ -0,0 +1,43 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using Umbraco.Cms.Infrastructure.Persistence.Dtos;
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_17_4_0;
+
+/// <summary>
+/// Adds an index on the versionDate column of the umbracoContentVersion table
+/// to support efficient date-based filtering and ordering in the content version cleanup job.
+/// </summary>
+public class AddContentVersionDateIndex : AsyncMigrationBase
+{
+    private const string IndexName = "IX_" + ContentVersionDto.TableName + "_VersionDate";
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AddContentVersionDateIndex"/> class.
+    /// </summary>
+    /// <param name="context">The migration context.</param>
+    public AddContentVersionDateIndex(IMigrationContext context)
+        : base(context)
+    {
+    }
+
+    /// <inheritdoc/>
+    protected override async Task MigrateAsync()
+    {
+        if (IndexExists(IndexName))
+        {
+            return;
+        }
+
+        // Give scope for the migration to complete within the command timeout, which may be necessary on large datasets.
+        EnsureLongCommandTimeout(Database);
+
+        // CREATE INDEX (without NONCLUSTERED) is portable across SQL Server and SQLite.
+        // SQL Server defaults to nonclustered; SQLite does not support the NONCLUSTERED keyword.
+        Execute.Sql($@"
+            CREATE INDEX [{IndexName}]
+            ON [{ContentVersionDto.TableName}] ([versionDate])
+        ").Do();
+    }
+}
diff --git a/src/Umbraco.Infrastructure/Migrations/Upgrade/V_17_4_0/AddDimensionsToSvg.cs b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_17_4_0/AddDimensionsToSvg.cs
new file mode 100644
index 000000000000..d5dfcf272ec7
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_17_4_0/AddDimensionsToSvg.cs
@@ -0,0 +1,101 @@
+using Microsoft.Extensions.Logging;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Core.Strings;
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_17_4_0;
+
+/// <summary>
+/// Migration that adds umbracoWidth and umbracoHeight to Vector Graphics Media Type.
+/// </summary>
+public class AddDimensionsToSvg : AsyncMigrationBase
+{
+    private readonly ILogger<AddDimensionsToSvg> _logger;
+    private readonly IMediaTypeService _mediaTypeService;
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IShortStringHelper _shortStringHelper;
+
+    private readonly Guid _labelPixelsDataTypeKey = new(Constants.DataTypes.Guids.LabelPixels);
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AddDimensionsToSvg"/> class.
+    /// </summary>
+    /// <param name="context">The <see cref="IMigrationContext"/> for the migration operation.</param>
+    /// <param name="logger">The <see cref="ILogger{AddDimensionsToSvg}"/> instance for logging.</param>
+    /// <param name="mediaTypeService">The <see cref="IMediaTypeService"/> for managing media types.</param>
+    /// <param name="dataTypeService">The <see cref="IDataTypeService"/> for managing data types.</param>
+    /// <param name="shortStringHelper">The <see cref="IShortStringHelper"/> for working with strings.</param>
+    public AddDimensionsToSvg(
+        IMigrationContext context,
+        ILogger<AddDimensionsToSvg> logger,
+        IMediaTypeService mediaTypeService,
+        IDataTypeService dataTypeService,
+        IShortStringHelper shortStringHelper)
+        : base(context)
+    {
+        _logger = logger;
+        _mediaTypeService = mediaTypeService;
+        _dataTypeService = dataTypeService;
+        _shortStringHelper = shortStringHelper;
+    }
+
+    /// <inheritdoc/>
+    protected override async Task MigrateAsync()
+    {
+        IMediaType? vectorGraphicsMediaType = _mediaTypeService.Get(Constants.Conventions.MediaTypes.VectorGraphicsAlias);
+
+        if (vectorGraphicsMediaType is null)
+        {
+            _logger.LogInformation("No standard Vector Graphics Media Type configured, ignore adding width/height.");
+            return;
+        }
+
+        IDataType? labelPixelDataType = await _dataTypeService.GetAsync(_labelPixelsDataTypeKey);
+
+        if (labelPixelDataType is null)
+        {
+            _logger.LogInformation("No Label Pixel Data Type configured, ignore adding width/height.");
+            return;
+        }
+
+        PropertyGroup? propertyGroup = vectorGraphicsMediaType.PropertyGroups.FirstOrDefault();
+        if (propertyGroup is null)
+        {
+            _logger.LogWarning("Vector Graphics Media Type has no property groups, skipping adding width/height.");
+            return;
+        }
+
+        int highestSort = vectorGraphicsMediaType.PropertyTypes.Any()
+            ? vectorGraphicsMediaType.PropertyTypes.Max(x => x.SortOrder)
+            : 0;
+
+        // Add new properties (AddPropertyType handles duplicates, so the migration is idempotent).
+        vectorGraphicsMediaType.AddPropertyType(new PropertyType(_shortStringHelper, labelPixelDataType, Constants.Conventions.Media.Width)
+        {
+            Name = "Width",
+            SortOrder = highestSort + 1,
+            PropertyGroupId = new Lazy<int>(()=> propertyGroup.Id),
+        });
+        vectorGraphicsMediaType.AddPropertyType(new PropertyType(_shortStringHelper, labelPixelDataType, Constants.Conventions.Media.Height)
+        {
+            Name = "Height",
+            SortOrder = highestSort + 2,
+            PropertyGroupId = new Lazy<int>(()=> propertyGroup.Id),
+        });
+
+        Attempt<ContentTypeOperationStatus> attempt = await _mediaTypeService.UpdateAsync(vectorGraphicsMediaType, Constants.Security.SuperUserKey);
+        if (attempt.Success is false)
+        {
+            if (attempt.Exception is not null)
+            {
+                _logger.LogError(attempt.Exception, "Failed to update media type '{Alias}' during migration.", vectorGraphicsMediaType.Alias);
+            }
+            else
+            {
+                _logger.LogWarning("Failed to update media type '{Alias}' during migration. Status: {ResultStatus}", vectorGraphicsMediaType.Alias, attempt.Result);
+            }
+        }
+    }
+}
diff --git a/src/Umbraco.Infrastructure/Migrations/Upgrade/V_18_0_0/AddDomainDto.cs b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_18_0_0/AddDomainDto.cs
new file mode 100644
index 000000000000..11c5cb28734a
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_18_0_0/AddDomainDto.cs
@@ -0,0 +1,22 @@
+using Umbraco.Cms.Persistence.EFCore.Migrations;
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_18_0_0;
+
+public class AddDomainDto : AsyncMigrationBase
+{
+    private readonly IEFCoreMigrationExecutor _migrationExecutor;
+
+    public AddDomainDto(
+        IMigrationContext context,
+        IEFCoreMigrationExecutor migrationExecutor)
+        : base(context)
+    {
+        _migrationExecutor = migrationExecutor;
+    }
+
+    protected override async Task MigrateAsync()
+    {
+        // NO-OP migration to ensure that EF Core doesn't complain about missing migrations.
+        await _migrationExecutor.ExecuteSingleMigrationAsync(EFCoreMigration.AddDomainDto);
+    }
+}
diff --git a/src/Umbraco.Infrastructure/Migrations/Upgrade/V_18_0_0/AddDomainKeyColumn.cs b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_18_0_0/AddDomainKeyColumn.cs
new file mode 100644
index 000000000000..b112ef69a8a4
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_18_0_0/AddDomainKeyColumn.cs
@@ -0,0 +1,55 @@
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos;
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_18_0_0;
+
+/// <summary>
+/// Adds the <c>key</c> column to the <c>umbracoDomain</c> table
+/// and populates it with a unique Guid for each existing row.
+/// This must run BEFORE the EF Core snapshot migration so that EF Core
+/// sees the column already present.
+/// </summary>
+public class AddDomainKeyColumn : AsyncMigrationBase
+{
+    const string indexName = "IX_umbracoDomain_key";
+
+    public AddDomainKeyColumn(IMigrationContext context)
+        : base(context)
+    {
+    }
+
+    protected override async Task MigrateAsync()
+    {
+        var tableName = Constants.DatabaseSchema.Tables.Domain;
+
+        if (TableExists(tableName) is false)
+        {
+            return;
+        }
+
+        const string columnName = DomainDto.KeyColumnName;
+
+        if (ColumnExists(tableName, columnName))
+        {
+            return;
+        }
+
+        // Add the column. existing rows will get a default empty Guid
+        AddColumn<DomainDto>(tableName, columnName);
+
+        // Populate each existing row with a new Guid
+        var domains = await Database.FetchAsync<DomainDto>($"SELECT * FROM {tableName}");
+        foreach (DomainDto domain in domains)
+        {
+            domain.Key = Guid.NewGuid();
+            await Database.ExecuteAsync(
+                $"UPDATE {tableName} SET {columnName} = @0 WHERE {DomainDto.PrimaryKeyColumnName} = @1",
+                [domain.Key, domain.Id]);
+        }
+
+        if (IndexExists(indexName) is false)
+        {
+            CreateIndex<DomainDto>(indexName);
+        }
+    }
+}
diff --git a/src/Umbraco.Infrastructure/Persistence/Dtos/ContentVersionDto.cs b/src/Umbraco.Infrastructure/Persistence/Dtos/ContentVersionDto.cs
index 74789344173d..11fd56babbe7 100644
--- a/src/Umbraco.Infrastructure/Persistence/Dtos/ContentVersionDto.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Dtos/ContentVersionDto.cs
@@ -45,6 +45,7 @@ public class ContentVersionDto
     /// </summary>
     /// <remarks>TODO: db rename to 'updateDate'</remarks>
     [Column(VersionDateColumnName)]
+    [Index(IndexTypes.NonClustered, Name = "IX_" + TableName + "_VersionDate")]
     [Constraint(Default = SystemMethods.CurrentUTCDateTime)]
     public DateTime VersionDate { get; set; }
 
diff --git a/src/Umbraco.Infrastructure/Persistence/Dtos/DocumentUrlDto.cs b/src/Umbraco.Infrastructure/Persistence/Dtos/DocumentUrlDto.cs
index 0656645876c4..ec0a43cccef4 100644
--- a/src/Umbraco.Infrastructure/Persistence/Dtos/DocumentUrlDto.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Dtos/DocumentUrlDto.cs
@@ -43,28 +43,13 @@ public class DocumentUrlDto
     [Column(IsDraftColumnName)]
     public bool IsDraft { get; set; }
 
-    /// <summary>
-    /// Gets or sets the language identifier associated with the document URL.
-    /// </summary>
-    /// <remarks>
-    /// This property returns 0 for invariant content. Use <see cref="NullableLanguageId"/> instead,
-    /// which correctly returns <c>null</c> for invariant content.
-    /// </remarks>
-    [Obsolete("Use NullableLanguageId instead. This property returns 0 for invariant content. Scheduled for removal in Umbraco 18, when the NullableLanguageId will also be renamed to LanguageId.")]
-    [Ignore]
-    public int LanguageId
-    {
-        get => NullableLanguageId ?? 0;
-        set => NullableLanguageId = value;
-    }
-
     /// <summary>
     /// Gets or sets the language Id. NULL indicates invariant content (not language-specific).
     /// </summary>
     [Column(LanguageIdColumnName)]
     [NullSetting(NullSetting = NullSettings.Null)]
     [ForeignKey(typeof(LanguageDto))]
-    public int? NullableLanguageId { get; set; }
+    public int? LanguageId { get; set; }
 
     /// <summary>
     /// Gets or sets the URL segment, which is the part of the document's URL typically used for routing and identifying the document in URLs.
diff --git a/src/Umbraco.Infrastructure/Persistence/Dtos/DomainDto.cs b/src/Umbraco.Infrastructure/Persistence/Dtos/DomainDto.cs
index 5eda6f9ea8f2..44175b05b5c5 100644
--- a/src/Umbraco.Infrastructure/Persistence/Dtos/DomainDto.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Dtos/DomainDto.cs
@@ -1,6 +1,7 @@
 using NPoco;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Infrastructure.Persistence.DatabaseAnnotations;
+using Umbraco.Cms.Infrastructure.Persistence.DatabaseModelDefinitions;
 
 namespace Umbraco.Cms.Infrastructure.Persistence.Dtos;
 
@@ -11,6 +12,7 @@ internal sealed class DomainDto
 {
     public const string TableName = Constants.DatabaseSchema.Tables.Domain;
     public const string PrimaryKeyColumnName = Constants.DatabaseSchema.Columns.PrimaryKeyNameId;
+    public const string KeyColumnName = "key";
 
     /// <summary>
     /// Gets or sets the unique identifier for the domain.
@@ -19,6 +21,15 @@ internal sealed class DomainDto
     [PrimaryKeyColumn]
     public int Id { get; set; }
 
+    /// <summary>
+    /// Gets or sets the globally unique key for the domain.
+    /// </summary>
+    [Column(KeyColumnName)]
+    [NullSetting(NullSetting = NullSettings.NotNull)]
+    [Constraint(Default = SystemMethods.NewGuid)]
+    [Index(IndexTypes.UniqueNonClustered, Name = "IX_umbracoDomain_key")]
+    public Guid Key { get; set; }
+
     /// <summary>
     /// Gets or sets the default language identifier for the domain.
     /// </summary>
diff --git a/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/Configurations/DomainDtoConfiguration.cs b/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/Configurations/DomainDtoConfiguration.cs
new file mode 100644
index 000000000000..f40ecd6eab61
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/Configurations/DomainDtoConfiguration.cs
@@ -0,0 +1,36 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Configurations;
+
+public class DomainDtoConfiguration : IEntityTypeConfiguration<DomainDto>
+{
+    public void Configure(EntityTypeBuilder<DomainDto> builder)
+    {
+        builder.ToTable(DomainDto.TableName);
+
+        builder.HasKey(x => x.Id);
+
+        builder.Property(x => x.Id)
+            .HasColumnName(DomainDto.PrimaryKeyColumnName)
+            .ValueGeneratedOnAdd();
+
+        builder.Property(x => x.Key)
+            .HasColumnName("key");
+
+        builder.HasIndex(x => x.Key)
+            .IsUnique();
+
+        builder.Property(x => x.DefaultLanguage)
+            .HasColumnName("domainDefaultLanguage");
+
+        builder.Property(x => x.RootStructureId)
+            .HasColumnName("domainRootStructureID");
+
+        builder.Property(x => x.DomainName)
+            .HasColumnName("domainName");
+
+        builder.Property(x => x.SortOrder)
+            .HasColumnName("sortOrder");
+    }
+}
diff --git a/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/Configurations/NodeDtoConfiguration.cs b/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/Configurations/NodeDtoConfiguration.cs
new file mode 100644
index 000000000000..9d02dfacf459
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/Configurations/NodeDtoConfiguration.cs
@@ -0,0 +1,91 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Configurations;
+
+public class NodeDtoConfiguration : IEntityTypeConfiguration<NodeDto>
+{
+    public void Configure(EntityTypeBuilder<NodeDto> builder)
+    {
+        builder.ToTable(NodeDto.TableName);
+
+        builder.HasKey(x => x.NodeId);
+
+        builder.Property(x => x.NodeId)
+            .HasColumnName(NodeDto.IdColumnName)
+            .ValueGeneratedOnAdd();
+
+        builder.Property(x => x.UniqueId)
+            .HasColumnName(NodeDto.KeyColumnName);
+
+        builder.Property(x => x.ParentId)
+            .HasColumnName(NodeDto.ParentIdColumnName);
+
+        builder.Property(x => x.Level)
+            .HasColumnName(NodeDto.LevelColumnName);
+
+        builder.Property(x => x.Path)
+            .HasColumnName(NodeDto.PathColumnName)
+            .HasMaxLength(150)
+            .IsRequired();
+
+        builder.Property(x => x.SortOrder)
+            .HasColumnName(NodeDto.SortOrderColumnName);
+
+        builder.Property(x => x.Trashed)
+            .HasColumnName(NodeDto.TrashedColumnName)
+            .HasDefaultValue(false);
+
+        builder.Property(x => x.UserId)
+            .HasColumnName(NodeDto.UserIdColumnName);
+
+        builder.Property(x => x.Text)
+            .HasColumnName(NodeDto.TextColumnName);
+
+        builder.Property(x => x.NodeObjectType)
+            .HasColumnName(NodeDto.NodeObjectTypeColumnName);
+
+        builder.Property(x => x.CreateDate)
+            .HasColumnName(NodeDto.CreateDateColumnName);
+
+        // Self-referencing FK: ParentId -> NodeId
+        builder.HasOne<NodeDto>()
+            .WithMany()
+            .HasForeignKey(x => x.ParentId)
+            .OnDelete(DeleteBehavior.NoAction);
+
+        // IX_umbracoNode_UniqueId (unique)
+        // Note: SQL Server included columns are added by SqlServerNodeDtoModelCustomizer.
+        builder.HasIndex(x => x.UniqueId)
+            .IsUnique()
+            .HasDatabaseName($"IX_{NodeDto.TableName}_UniqueId");
+
+        // IX_umbracoNode_parentId_nodeObjectType
+        // Note: SQL Server included columns are added by SqlServerNodeDtoModelCustomizer.
+        builder.HasIndex(x => new { x.ParentId, x.NodeObjectType })
+            .HasDatabaseName($"IX_{NodeDto.TableName}_parentId_nodeObjectType");
+
+        // IX_umbracoNode_Level
+        // Note: SQL Server included columns are added by SqlServerNodeDtoModelCustomizer.
+        builder.HasIndex(x => new { x.Level, x.ParentId, x.SortOrder, x.NodeObjectType, x.Trashed })
+            .HasDatabaseName($"IX_{NodeDto.TableName}_Level");
+
+        // IX_umbracoNode_Path
+        builder.HasIndex(x => x.Path)
+            .HasDatabaseName($"IX_{NodeDto.TableName}_Path");
+
+        // IX_umbracoNode_ObjectType_trashed_sorted
+        // Note: SQL Server included columns are added by SqlServerNodeDtoModelCustomizer.
+        builder.HasIndex(x => new { x.NodeObjectType, x.Trashed, x.SortOrder, x.NodeId })
+            .HasDatabaseName($"IX_{NodeDto.TableName}_ObjectType_trashed_sorted");
+
+        // IX_umbracoNode_Trashed
+        builder.HasIndex(x => x.Trashed)
+            .HasDatabaseName($"IX_{NodeDto.TableName}_Trashed");
+
+        // IX_umbracoNode_ObjectType
+        // Note: SQL Server included columns are added by SqlServerNodeDtoModelCustomizer.
+        builder.HasIndex(x => new { x.NodeObjectType, x.Trashed })
+            .HasDatabaseName($"IX_{NodeDto.TableName}_ObjectType");
+    }
+}
diff --git a/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/DomainDto.cs b/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/DomainDto.cs
new file mode 100644
index 000000000000..895a2c2d986f
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/DomainDto.cs
@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Configurations;
+
+namespace Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore;
+
+[EntityTypeConfiguration(typeof(DomainDtoConfiguration))]
+public class DomainDto
+{
+    public const string TableName = Constants.DatabaseSchema.Tables.Domain;
+    public const string PrimaryKeyColumnName = Constants.DatabaseSchema.Columns.PrimaryKeyNameId;
+
+    public int Id { get; set; }
+
+    public Guid Key { get; set; }
+
+    public int? DefaultLanguage { get; set; }
+
+    public int? RootStructureId { get; set; }
+
+    public string DomainName { get; set; } = null!;
+
+    public int SortOrder { get; set; }
+}
diff --git a/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/NodeDto.cs b/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/NodeDto.cs
new file mode 100644
index 000000000000..ed80c7cbaa13
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Persistence/Dtos/EFCore/NodeDto.cs
@@ -0,0 +1,82 @@
+using Microsoft.EntityFrameworkCore;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore.Configurations;
+
+namespace Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore;
+
+[EntityTypeConfiguration(typeof(NodeDtoConfiguration))]
+public class NodeDto
+{
+    public const string TableName = Constants.DatabaseSchema.Tables.Node;
+    public const string PrimaryKeyColumnName = Constants.DatabaseSchema.Columns.PrimaryKeyNameId;
+
+    // Public constants to bind properties between DTOs
+    public const string IdColumnName = PrimaryKeyColumnName;
+    public const string KeyColumnName = Constants.DatabaseSchema.Columns.UniqueIdName;
+    public const string ParentIdColumnName = "parentId";
+    public const string SortOrderColumnName = "sortOrder";
+    public const string TrashedColumnName = "trashed";
+    public const string NodeObjectTypeColumnName = "nodeObjectType";
+    public const string TextColumnName = "text";
+    public const string PathColumnName = "path";
+    public const string LevelColumnName = "level";
+    public const string UserIdColumnName = "nodeUser";
+    public const string CreateDateColumnName = "createDate";
+
+    private int? _userId;
+
+    /// <summary>
+    /// Gets or sets the unique identifier for the node.
+    /// </summary>
+    public int NodeId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the globally unique identifier (GUID) that uniquely identifies this node.
+    /// </summary>
+    public Guid UniqueId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the identifier of the parent node.
+    /// </summary>
+    public int ParentId { get; set; }
+
+    /// <summary>
+    /// Gets or sets the depth level of the node within the content tree hierarchy.
+    /// </summary>
+    public short Level { get; set; }
+
+    /// <summary>
+    /// Gets or sets the hierarchical path of the node.
+    /// </summary>
+    public string Path { get; set; } = null!;
+
+    /// <summary>
+    /// Gets or sets the position of the node relative to its siblings.
+    /// </summary>
+    public int SortOrder { get; set; }
+
+    /// <summary>
+    /// Gets or sets a value indicating whether this node is in the trash.
+    /// </summary>
+    public bool Trashed { get; set; }
+
+    /// <summary>
+    /// Gets or sets the identifier of the user who created the node.
+    /// </summary>
+    public int? UserId { get => _userId == 0 ? null : _userId; set => _userId = value; }
+
+    /// <summary>
+    /// Gets or sets the display text or name associated with the node.
+    /// </summary>
+    public string? Text { get; set; }
+
+    /// <summary>
+    /// Gets or sets the object type GUID associated with this node.
+    /// </summary>
+    public Guid? NodeObjectType { get; set; }
+
+    /// <summary>
+    /// Gets or sets the date and time when the node was created.
+    /// </summary>
+    public DateTime CreateDate { get; set; }
+}
diff --git a/src/Umbraco.Infrastructure/Persistence/EFCore/EfCoreMigrationExecutor.cs b/src/Umbraco.Infrastructure/Persistence/EFCore/EfCoreMigrationExecutor.cs
index 08483da9bc8d..78287f2df11c 100644
--- a/src/Umbraco.Infrastructure/Persistence/EFCore/EfCoreMigrationExecutor.cs
+++ b/src/Umbraco.Infrastructure/Persistence/EFCore/EfCoreMigrationExecutor.cs
@@ -9,18 +9,18 @@ namespace Umbraco.Cms.Infrastructure.Persistence.EFCore;
 /// <summary>
 /// Executes Entity Framework Core migrations for Umbraco.
 /// </summary>
-public class EfCoreMigrationExecutor : IEFCoreMigrationExecutor
+public class EFCoreMigrationExecutor : IEFCoreMigrationExecutor
 {
     private readonly IEnumerable<IMigrationProvider> _migrationProviders;
     private readonly IOptions<ConnectionStrings> _options;
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="EfCoreMigrationExecutor"/> class.
+    /// Initializes a new instance of the <see cref="EFCoreMigrationExecutor"/> class.
     /// </summary>
     /// <param name="migrationProviders">The collection of migration providers.</param>
     /// <param name="options">The connection string options.</param>
     /// <remarks>We need to do migrations outside of a scope due to SQLite.</remarks>
-    public EfCoreMigrationExecutor(
+    public EFCoreMigrationExecutor(
         IEnumerable<IMigrationProvider> migrationProviders,
         IOptions<ConnectionStrings> options)
     {
diff --git a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/AmbientEFCoreScopeStack.cs b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/AmbientEFCoreScopeStack.cs
index fb84273f3b11..bc22c6d33df1 100644
--- a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/AmbientEFCoreScopeStack.cs
+++ b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/AmbientEFCoreScopeStack.cs
@@ -12,16 +12,17 @@ namespace Umbraco.Cms.Infrastructure.Persistence.EFCore.Scoping;
 public class AmbientEFCoreScopeStack<TDbContext> : IAmbientEFCoreScopeStack<TDbContext> where TDbContext : DbContext
 {
     private static Lock _lock = new();
-    private static AsyncLocal<ConcurrentStack<IEfCoreScope<TDbContext>>> _stack = new();
+    private static AsyncLocal<ConcurrentStack<IEFCoreScope<TDbContext>>> _stack = new();
+    private IEFCoreScope<TDbContext>? _ambientScope;
 
     /// <inheritdoc />
-    public IEfCoreScope<TDbContext>? AmbientScope
+    public IEFCoreScope<TDbContext>? AmbientScope
     {
         get
         {
             lock (_lock)
             {
-                if (_stack.Value?.TryPeek(out IEfCoreScope<TDbContext>? ambientScope) ?? false)
+                if (_stack.Value?.TryPeek(out IEFCoreScope<TDbContext>? ambientScope) ?? false)
                 {
                     return ambientScope;
                 }
@@ -35,11 +36,11 @@ public IEfCoreScope<TDbContext>? AmbientScope
     ICoreScope? CoreEFCoreScopeAccessor.AmbientScope => AmbientScope;
 
     /// <inheritdoc />
-    public IEfCoreScope<TDbContext> Pop()
+    public IEFCoreScope<TDbContext> Pop()
     {
         lock (_lock)
         {
-            if (_stack.Value?.TryPop(out IEfCoreScope<TDbContext>? ambientScope) ?? false)
+            if (_stack.Value?.TryPop(out IEFCoreScope<TDbContext>? ambientScope) ?? false)
             {
                 return ambientScope;
             }
@@ -49,13 +50,15 @@ public IEfCoreScope<TDbContext> Pop()
     }
 
     /// <inheritdoc />
-    public void Push(IEfCoreScope<TDbContext> scope)
+    public void Push(IEFCoreScope<TDbContext> scope)
     {
         lock (_lock)
         {
-            _stack.Value ??= new ConcurrentStack<IEfCoreScope<TDbContext>>();
+            _stack.Value ??= new ConcurrentStack<IEFCoreScope<TDbContext>>();
 
             _stack.Value.Push(scope);
         }
     }
+
+    IEFCoreScope<TDbContext>? IEFCoreScopeAccessor<TDbContext>.AmbientScope => _ambientScope;
 }
diff --git a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScope.cs b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScope.cs
index 78607cd987bd..4d4f49e76cb8 100644
--- a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScope.cs
+++ b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScope.cs
@@ -16,7 +16,7 @@ namespace Umbraco.Cms.Infrastructure.Persistence.EFCore.Scoping;
 /// Represents an EF Core scope that provides database context access and transaction management.
 /// </summary>
 /// <typeparam name="TDbContext">The type of DbContext.</typeparam>
-internal class EFCoreScope<TDbContext> : CoreScope, IEfCoreScope<TDbContext>
+internal class EFCoreScope<TDbContext> : CoreScope, IEFCoreScope<TDbContext>
     where TDbContext : DbContext
 {
     private readonly IEFCoreScopeAccessor<TDbContext> _efCoreScopeAccessor;
@@ -192,7 +192,7 @@ public override void Dispose()
                 // Stack was empty the push was reverted by async execution context restoration.
             }
 
-            DisposeEfCoreDatabase();
+            DisposeEFCoreDatabase();
             _disposed = true;
             return;
         }
@@ -206,7 +206,7 @@ public override void Dispose()
 
         if (ParentScope is null)
         {
-            DisposeEfCoreDatabase();
+            DisposeEFCoreDatabase();
         }
 
         Locks.ClearLocks(InstanceId);
@@ -321,7 +321,7 @@ private void HandleScopeContext()
         }
     }
 
-    private void DisposeEfCoreDatabase()
+    private void DisposeEFCoreDatabase()
     {
         var completed = Completed.HasValue && Completed.Value;
         {
diff --git a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScopeAccessor.cs b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScopeAccessor.cs
index 943f416d38e2..e84749fad5e3 100644
--- a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScopeAccessor.cs
+++ b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScopeAccessor.cs
@@ -49,7 +49,7 @@ public bool HasBridgedAmbientScope
         => _ambientEfCoreScopeStack.AmbientScope is not EFCoreScope<TDbContext> { IsBridgeScope: false };
 
     /// <inheritdoc />
-    IEfCoreScope<TDbContext>? IEFCoreScopeAccessor<TDbContext>.AmbientScope => GetOrCreateAmbientScope();
+    IEFCoreScope<TDbContext>? IEFCoreScopeAccessor<TDbContext>.AmbientScope => GetOrCreateAmbientScope();
 
     /// <inheritdoc />
     ICoreScope? CoreEFCoreScopeAccessor.AmbientScope => GetOrCreateAmbientScope();
@@ -61,9 +61,9 @@ public bool HasBridgedAmbientScope
     ///
     /// This is temporary and should be removed when all repositories are migrated to EF Core.
     /// </summary>
-    private IEfCoreScope<TDbContext>? GetOrCreateAmbientScope()
+    private IEFCoreScope<TDbContext>? GetOrCreateAmbientScope()
     {
-        IEfCoreScope<TDbContext>? scope = _ambientEfCoreScopeStack.AmbientScope;
+        IEFCoreScope<TDbContext>? scope = _ambientEfCoreScopeStack.AmbientScope;
 
         if (scope is not null)
         {
diff --git a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScopeProvider.cs b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScopeProvider.cs
index 89ccfbf4374f..a67b6a88d253 100644
--- a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScopeProvider.cs
+++ b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/EFCoreScopeProvider.cs
@@ -20,10 +20,10 @@ namespace Umbraco.Cms.Infrastructure.Persistence.EFCore.Scoping;
 /// <typeparam name="TDbContext">The type of DbContext.</typeparam>
 internal sealed class EFCoreScopeProvider<TDbContext> : IEFCoreScopeProvider<TDbContext> where TDbContext : DbContext
 {
-    private readonly IAmbientEFCoreScopeStack<TDbContext> _ambientEfCoreScopeStack;
+    private readonly IAmbientEFCoreScopeStack<TDbContext> _ambientEFCoreScopeStack;
     private readonly ILoggerFactory _loggerFactory;
     private readonly IEFCoreScopeAccessor<TDbContext> _efCoreScopeAccessor;
-    private readonly IAmbientScopeContextStack _ambientEfCoreScopeContextStack;
+    private readonly IAmbientScopeContextStack _ambientEFCoreScopeContextStack;
     private readonly IDistributedLockingMechanismFactory _distributedLockingMechanismFactory;
     private readonly IEventAggregator _eventAggregator;
     private readonly FileSystems _fileSystems;
@@ -33,7 +33,7 @@ internal sealed class EFCoreScopeProvider<TDbContext> : IEFCoreScopeProvider<TDb
     /// <summary>
     /// Initializes a new instance of the <see cref="EFCoreScopeProvider{TDbContext}"/> class.
     /// </summary>
-    /// <remarks>Needed for DI as IAmbientEfCoreScopeStack is internal.</remarks>
+    /// <remarks>Needed for DI as IAmbientEFCoreScopeStack is internal.</remarks>
     public EFCoreScopeProvider()
         : this(
             StaticServiceProvider.Instance.GetRequiredService<IAmbientEFCoreScopeStack<TDbContext>>(),
@@ -51,30 +51,30 @@ public EFCoreScopeProvider()
     /// <summary>
     /// Initializes a new instance of the <see cref="EFCoreScopeProvider{TDbContext}"/> class with explicit dependencies.
     /// </summary>
-    /// <param name="ambientEfCoreScopeStack">The ambient scope stack.</param>
+    /// <param name="ambientEFCoreScopeStack">The ambient scope stack.</param>
     /// <param name="loggerFactory">The logger factory.</param>
     /// <param name="efCoreScopeAccessor">The scope accessor.</param>
-    /// <param name="ambientEfCoreScopeContextStack">The ambient scope context stack.</param>
+    /// <param name="ambientEFCoreScopeContextStack">The ambient scope context stack.</param>
     /// <param name="distributedLockingMechanismFactory">The distributed locking mechanism factory.</param>
     /// <param name="eventAggregator">The event aggregator.</param>
     /// <param name="fileSystems">The file systems.</param>
     /// <param name="scopeProvider">The scope provider.</param>
     /// <param name="dbContextFactory">The DbContext factory.</param>
     internal EFCoreScopeProvider(
-        IAmbientEFCoreScopeStack<TDbContext> ambientEfCoreScopeStack,
+        IAmbientEFCoreScopeStack<TDbContext> ambientEFCoreScopeStack,
         ILoggerFactory loggerFactory,
         IEFCoreScopeAccessor<TDbContext> efCoreScopeAccessor,
-        IAmbientScopeContextStack ambientEfCoreScopeContextStack,
+        IAmbientScopeContextStack ambientEFCoreScopeContextStack,
         IDistributedLockingMechanismFactory distributedLockingMechanismFactory,
         IEventAggregator eventAggregator,
         FileSystems fileSystems,
         IScopeProvider scopeProvider,
         IDbContextFactory<TDbContext> dbContextFactory)
     {
-        _ambientEfCoreScopeStack = ambientEfCoreScopeStack;
+        _ambientEFCoreScopeStack = ambientEFCoreScopeStack;
         _loggerFactory = loggerFactory;
         _efCoreScopeAccessor = efCoreScopeAccessor;
-        _ambientEfCoreScopeContextStack = ambientEfCoreScopeContextStack;
+        _ambientEFCoreScopeContextStack = ambientEFCoreScopeContextStack;
         _distributedLockingMechanismFactory = distributedLockingMechanismFactory;
         _eventAggregator = eventAggregator;
         _fileSystems = fileSystems;
@@ -84,7 +84,7 @@ internal EFCoreScopeProvider(
     }
 
     /// <inheritdoc />
-    public IEfCoreScope<TDbContext> CreateDetachedScope(
+    public IEFCoreScope<TDbContext> CreateDetachedScope(
         RepositoryCacheMode repositoryCacheMode = RepositoryCacheMode.Unspecified,
         bool? scopeFileSystems = null) =>
         new EFCoreDetachableScope<TDbContext>(
@@ -100,7 +100,7 @@ public IEfCoreScope<TDbContext> CreateDetachedScope(
             scopeFileSystems);
 
     /// <inheritdoc />
-    public void AttachScope(IEfCoreScope<TDbContext> other)
+    public void AttachScope(IEFCoreScope<TDbContext> other)
     {
         // IScopeProvider.AttachScope works with an IEFCoreScope
         // but here we can only deal with our own Scope class
@@ -120,17 +120,17 @@ public void AttachScope(IEfCoreScope<TDbContext> other)
         }
 
         otherScope.Attached = true;
-        otherScope.OriginalScope = (EFCoreScope<TDbContext>)_ambientEfCoreScopeStack.AmbientScope!;
+        otherScope.OriginalScope = (EFCoreScope<TDbContext>)_ambientEFCoreScopeStack.AmbientScope!;
         otherScope.OriginalContext = AmbientScopeContext;
 
         PushAmbientScopeContext(otherScope.ScopeContext);
-        _ambientEfCoreScopeStack.Push(otherScope);
+        _ambientEFCoreScopeStack.Push(otherScope);
     }
 
     /// <inheritdoc />
-    public IEfCoreScope<TDbContext> DetachScope()
+    public IEFCoreScope<TDbContext> DetachScope()
     {
-        if (_ambientEfCoreScopeStack.AmbientScope is not EFCoreDetachableScope<TDbContext> ambientScope)
+        if (_ambientEFCoreScopeStack.AmbientScope is not EFCoreDetachableScope<TDbContext> ambientScope)
         {
             throw new InvalidOperationException("Ambient scope is not detachable");
         }
@@ -148,16 +148,16 @@ public IEfCoreScope<TDbContext> DetachScope()
         PopAmbientScope();
         PopAmbientScopeContext();
 
-        var originalScope = (EFCoreScope<TDbContext>)_ambientEfCoreScopeStack.AmbientScope!;
+        var originalScope = (EFCoreScope<TDbContext>)_ambientEFCoreScopeStack.AmbientScope!;
         if (originalScope != ambientScope.OriginalScope)
         {
-            throw new InvalidOperationException($"The detatched scope ({ambientScope.InstanceId}) does not match the original ({originalScope.InstanceId})");
+            throw new InvalidOperationException($"The detached scope ({ambientScope.InstanceId}) does not match the original ({originalScope.InstanceId})");
         }
 
         IScopeContext? originalScopeContext = AmbientScopeContext;
         if (originalScopeContext != ambientScope.OriginalContext)
         {
-            throw new InvalidOperationException($"The detatched scope context does not match the original");
+            throw new InvalidOperationException($"The detached scope context does not match the original");
         }
 
         ambientScope.OriginalScope = null;
@@ -183,15 +183,15 @@ public IEfCoreScope<TDbContext> DetachScope()
     internal int ScopeContextDepth => _scopeContextDepth.Value;
 
     /// <inheritdoc />
-    public IScopeContext? AmbientScopeContext => _ambientEfCoreScopeContextStack.AmbientContext;
+    public IScopeContext? AmbientScopeContext => _ambientEFCoreScopeContextStack.AmbientContext;
 
     /// <inheritdoc />
-    public IEfCoreScope<TDbContext> CreateScope(
+    public IEFCoreScope<TDbContext> CreateScope(
         RepositoryCacheMode repositoryCacheMode = RepositoryCacheMode.Unspecified, bool? scopeFileSystems = null)
     {
-        if (_ambientEfCoreScopeStack.AmbientScope is null)
+        if (_ambientEFCoreScopeStack.AmbientScope is null)
         {
-            ScopeContext? newContext = _ambientEfCoreScopeContextStack.AmbientContext == null ? new ScopeContext() : null;
+            ScopeContext? newContext = _ambientEFCoreScopeContextStack.AmbientContext == null ? new ScopeContext() : null;
             IScope parentScope = _scopeProvider.CreateScope(IsolationLevel.Unspecified, repositoryCacheMode, null, null, scopeFileSystems);
             var ambientScope = new EFCoreScope<TDbContext>(
                 parentScope,
@@ -211,12 +211,12 @@ public IEfCoreScope<TDbContext> CreateScope(
                 PushAmbientScopeContext(newContext);
             }
 
-            _ambientEfCoreScopeStack.Push(ambientScope);
+            _ambientEFCoreScopeStack.Push(ambientScope);
             return ambientScope;
         }
 
         var efCoreScope = new EFCoreScope<TDbContext>(
-            (EFCoreScope<TDbContext>)_ambientEfCoreScopeStack.AmbientScope,
+            (EFCoreScope<TDbContext>)_ambientEFCoreScopeStack.AmbientScope,
             _distributedLockingMechanismFactory,
             _loggerFactory,
             _efCoreScopeAccessor,
@@ -228,7 +228,7 @@ public IEfCoreScope<TDbContext> CreateScope(
             repositoryCacheMode,
             scopeFileSystems);
 
-        _ambientEfCoreScopeStack.Push(efCoreScope);
+        _ambientEFCoreScopeStack.Push(efCoreScope);
         return efCoreScope;
     }
 
@@ -247,10 +247,10 @@ public IEfCoreScope<TDbContext> CreateScope(
     /// </summary>
     /// <param name="existingNPocoScope">The existing ambient NPoco scope.</param>
     /// <returns>The created bridge scope which is pushed onto the stack.</returns>
-    internal IEfCoreScope<TDbContext> CreateBridgeScope(IScope existingNPocoScope)
+    internal IEFCoreScope<TDbContext> CreateBridgeScope(IScope existingNPocoScope)
     {
         // Check if a bridge scope was already created for this scope context.
-        IEfCoreScope<TDbContext>? existing = _scopeProvider.Context!.GetEnlisted<IEfCoreScope<TDbContext>>(BridgeScopeContextKey);
+        IEFCoreScope<TDbContext>? existing = _scopeProvider.Context!.GetEnlisted<IEFCoreScope<TDbContext>>(BridgeScopeContextKey);
         if (existing is not null)
         {
             return existing;
@@ -270,10 +270,10 @@ internal IEfCoreScope<TDbContext> CreateBridgeScope(IScope existingNPocoScope)
             IsBridgeScope = true,
         };
 
-        _ambientEfCoreScopeStack.Push(bridgeScope);
+        _ambientEFCoreScopeStack.Push(bridgeScope);
         bridgeScope.Complete();
 
-        _scopeProvider.Context!.Enlist<IEfCoreScope<TDbContext>>(
+        _scopeProvider.Context!.Enlist<IEFCoreScope<TDbContext>>(
             BridgeScopeContextKey,
             () => bridgeScope,
             (_, scope) => scope?.Dispose());
@@ -284,7 +284,7 @@ internal IEfCoreScope<TDbContext> CreateBridgeScope(IScope existingNPocoScope)
     /// <summary>
     /// Removes the current ambient scope from the stack.
     /// </summary>
-    public void PopAmbientScope() => _ambientEfCoreScopeStack.Pop();
+    public void PopAmbientScope() => _ambientEFCoreScopeStack.Pop();
 
     /// <summary>
     /// Pushes a scope context onto the ambient scope context stack.
@@ -299,7 +299,7 @@ public void PushAmbientScopeContext(IScopeContext? scopeContext)
         }
 
         _scopeContextDepth.Value++;
-        _ambientEfCoreScopeContextStack.Push(scopeContext);
+        _ambientEFCoreScopeContextStack.Push(scopeContext);
     }
 
     /// <summary>
@@ -308,7 +308,7 @@ public void PushAmbientScopeContext(IScopeContext? scopeContext)
     public void PopAmbientScopeContext()
     {
         _scopeContextDepth.Value--;
-        _ambientEfCoreScopeContextStack.Pop();
+        _ambientEFCoreScopeContextStack.Pop();
     }
 
     /// <inheritdoc />
@@ -322,9 +322,9 @@ ICoreScope CoreEFCoreScopeProvider.CreateDetachedScope(RepositoryCacheMode repos
     /// <inheritdoc />
     void CoreEFCoreScopeProvider.AttachScope(ICoreScope other)
     {
-        if (other is not IEfCoreScope<TDbContext> efCoreScope)
+        if (other is not IEFCoreScope<TDbContext> efCoreScope)
         {
-            throw new ArgumentException($"Scope must be an IEfCoreScope<{typeof(TDbContext).Name}>.", nameof(other));
+            throw new ArgumentException($"Scope must be an IEFCoreScope<{typeof(TDbContext).Name}>.", nameof(other));
         }
 
         AttachScope(efCoreScope);
diff --git a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IAmbientEfCoreScopeStack.cs b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IAmbientEfCoreScopeStack.cs
index ff2b34676c3d..fb70c63cfa75 100644
--- a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IAmbientEfCoreScopeStack.cs
+++ b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IAmbientEfCoreScopeStack.cs
@@ -11,17 +11,17 @@ internal interface IAmbientEFCoreScopeStack<TDbContext> : IEFCoreScopeAccessor<T
     /// <summary>
     /// Gets the current ambient scope at the top of the stack.
     /// </summary>
-    new IEfCoreScope<TDbContext>? AmbientScope { get; }
+    new IEFCoreScope<TDbContext>? AmbientScope { get; }
 
     /// <summary>
     /// Removes and returns the scope at the top of the stack.
     /// </summary>
     /// <returns>The scope that was removed from the top of the stack.</returns>
-    IEfCoreScope<TDbContext> Pop();
+    IEFCoreScope<TDbContext> Pop();
 
     /// <summary>
     /// Pushes a scope onto the top of the stack.
     /// </summary>
     /// <param name="scope">The scope to push onto the stack.</param>
-    void Push(IEfCoreScope<TDbContext> scope);
+    void Push(IEFCoreScope<TDbContext> scope);
 }
diff --git a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScope.cs b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScope.cs
index 9e2917609dbd..7311424a56f7 100644
--- a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScope.cs
+++ b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScope.cs
@@ -7,7 +7,7 @@ namespace Umbraco.Cms.Infrastructure.Persistence.EFCore.Scoping;
 /// Represents an EF Core scope that provides database context access and transaction management.
 /// </summary>
 /// <typeparam name="TDbContext">The type of DbContext.</typeparam>
-public interface IEfCoreScope<TDbContext> : ICoreScope
+public interface IEFCoreScope<TDbContext> : ICoreScope
 {
     /// <summary>
     /// Executes the given function on the database.
diff --git a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScopeAccessor.cs b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScopeAccessor.cs
index 0df90de84908..025f6dc6eb12 100644
--- a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScopeAccessor.cs
+++ b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScopeAccessor.cs
@@ -1,3 +1,4 @@
+using Umbraco.Cms.Core.DistributedLocking;
 using CoreEFCoreScopeAccessor = Umbraco.Cms.Core.Scoping.EFCore.IScopeAccessor;
 
 namespace Umbraco.Cms.Infrastructure.Persistence.EFCore.Scoping;
@@ -16,7 +17,7 @@ public interface IEFCoreScopeAccessor<TDbContext> : CoreEFCoreScopeAccessor
     ///     when only an NPoco scope is active; use <see cref="HasNonBridgeAmbientScope"/> to
     ///     check for a genuine EF Core scope without side effects.
     /// </remarks>
-    new IEfCoreScope<TDbContext>? AmbientScope { get; }
+    new IEFCoreScope<TDbContext>? AmbientScope { get; }
 
     /// <summary>
     ///     Gets a value indicating whether there is no genuine (non-bridge) EF Core ambient scope on the stack.
diff --git a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScopeProvider.cs b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScopeProvider.cs
index 2932aca50a1f..393d13c44487 100644
--- a/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScopeProvider.cs
+++ b/src/Umbraco.Infrastructure/Persistence/EFCore/Scoping/IEFCoreScopeProvider.cs
@@ -15,7 +15,7 @@ public interface IEFCoreScopeProvider<TDbContext> : CoreEFCoreScopeProvider
     /// <param name="repositoryCacheMode">The repository cache mode.</param>
     /// <param name="scopeFileSystems">Whether to scope file systems.</param>
     /// <returns>The created scope.</returns>
-    new IEfCoreScope<TDbContext> CreateScope(RepositoryCacheMode repositoryCacheMode = RepositoryCacheMode.Unspecified, bool? scopeFileSystems = null);
+    new IEFCoreScope<TDbContext> CreateScope(RepositoryCacheMode repositoryCacheMode = RepositoryCacheMode.Unspecified, bool? scopeFileSystems = null);
 
     /// <summary>
     /// Creates a new detached EF Core scope that can be attached later.
@@ -23,19 +23,19 @@ public interface IEFCoreScopeProvider<TDbContext> : CoreEFCoreScopeProvider
     /// <param name="repositoryCacheMode">The repository cache mode.</param>
     /// <param name="scopeFileSystems">Whether to scope file systems.</param>
     /// <returns>The created detached scope.</returns>
-    new IEfCoreScope<TDbContext> CreateDetachedScope(RepositoryCacheMode repositoryCacheMode = RepositoryCacheMode.Unspecified, bool? scopeFileSystems = null);
+    new IEFCoreScope<TDbContext> CreateDetachedScope(RepositoryCacheMode repositoryCacheMode = RepositoryCacheMode.Unspecified, bool? scopeFileSystems = null);
 
     /// <summary>
     /// Attaches a detached scope to the current ambient scope stack.
     /// </summary>
     /// <param name="other">The detached scope to attach.</param>
-    void AttachScope(IEfCoreScope<TDbContext> other);
+    void AttachScope(IEFCoreScope<TDbContext> other);
 
     /// <summary>
     /// Detaches the current ambient scope from the stack.
     /// </summary>
     /// <returns>The detached scope.</returns>
-    new IEfCoreScope<TDbContext> DetachScope();
+    new IEFCoreScope<TDbContext> DetachScope();
 
     /// <summary>
     /// Gets the ambient scope context.
diff --git a/src/Umbraco.Infrastructure/Persistence/EFCore/UmbracoDbContext.cs b/src/Umbraco.Infrastructure/Persistence/EFCore/UmbracoDbContext.cs
index 69985e95f1ea..b44df39e71a6 100644
--- a/src/Umbraco.Infrastructure/Persistence/EFCore/UmbracoDbContext.cs
+++ b/src/Umbraco.Infrastructure/Persistence/EFCore/UmbracoDbContext.cs
@@ -56,6 +56,10 @@ public UmbracoDbContext(DbContextOptions<UmbracoDbContext> options, IEnumerable<
 
     public required DbSet<LanguageDto> Language { get; set; }
 
+    public required DbSet<DomainDto> Domains { get; set; }
+
+    public required DbSet<NodeDto> Nodes { get; set; }
+
     private static DbContextOptions<UmbracoDbContext> ConfigureOptions(DbContextOptions<UmbracoDbContext> options)
     {
         var coreExtensions = options.FindExtension<Microsoft.EntityFrameworkCore.Infrastructure.CoreOptionsExtension>();
diff --git a/src/Umbraco.Infrastructure/Persistence/Factories/DomainFactory.cs b/src/Umbraco.Infrastructure/Persistence/Factories/DomainFactory.cs
index 9a1011e66ab0..bdd264858937 100644
--- a/src/Umbraco.Infrastructure/Persistence/Factories/DomainFactory.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Factories/DomainFactory.cs
@@ -1,10 +1,5 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Umbraco.Cms.Core.Models;
-using Umbraco.Cms.Infrastructure.Persistence.Dtos;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore;
 
 namespace Umbraco.Cms.Infrastructure.Persistence.Factories;
 
@@ -14,14 +9,18 @@ internal static class DomainFactory
     /// Creates an <see cref="Umbraco.Cms.Core.Models.IDomain"/> entity from the specified <see cref="Umbraco.Cms.Infrastructure.Persistence.Dtos.DomainDto"/>.
     /// </summary>
     /// <param name="dto">The <see cref="Umbraco.Cms.Infrastructure.Persistence.Dtos.DomainDto"/> containing the domain data to map.</param>
+    /// <param name="isoCode">The ISO code for the language.</param>
+    /// <param name="rootContentKey">The key (Guid) of the root content node, resolved from the umbracoNode table.</param>
     /// <returns>An <see cref="Umbraco.Cms.Core.Models.IDomain"/> instance representing the mapped domain.</returns>
-    public static IDomain BuildEntity(DomainDto dto)
+    public static IDomain BuildEntity(DomainDto dto, string? isoCode, Guid? rootContentKey = null)
     {
-        var domain = new UmbracoDomain(dto.DomainName, dto.IsoCode)
+        var domain = new UmbracoDomain(dto.DomainName, isoCode ?? string.Empty)
         {
             Id = dto.Id,
+            Key = dto.Key,
             LanguageId = dto.DefaultLanguage,
             RootContentId = dto.RootStructureId,
+            RootContentKey = rootContentKey,
             SortOrder = dto.SortOrder,
         };
 
@@ -31,6 +30,35 @@ public static IDomain BuildEntity(DomainDto dto)
         return domain;
     }
 
+    /// <summary>
+    /// Creates a collection of <see cref="IDomain"/> entities from the specified DTOs,
+    /// using pre-loaded lookup dictionaries for language ISO codes and content node keys.
+    /// </summary>
+    /// <param name="dtos">The domain DTOs to map.</param>
+    /// <param name="isoCodeLookup">A dictionary mapping language IDs to their ISO codes.</param>
+    /// <param name="nodeKeyLookup">A dictionary mapping node IDs to their unique keys (Guids).</param>
+    /// <returns>A collection of <see cref="IDomain"/> entities.</returns>
+    public static IEnumerable<IDomain> BuildEntities(
+        List<DomainDto> dtos,
+        Dictionary<int, string> isoCodeLookup,
+        Dictionary<int, Guid> nodeKeyLookup)
+    {
+        return dtos.Select(dto =>
+        {
+            string? isoCode = dto.DefaultLanguage.HasValue
+                && isoCodeLookup.TryGetValue(dto.DefaultLanguage.Value, out var code)
+                ? code
+                : null;
+
+            Guid? rootContentKey = dto.RootStructureId.HasValue
+                && nodeKeyLookup.TryGetValue(dto.RootStructureId.Value, out Guid key)
+                ? key
+                : null;
+
+            return BuildEntity(dto, isoCode, rootContentKey);
+        });
+    }
+
     /// <summary>
     /// Builds a <see cref="DomainDto"/> from the given <see cref="IDomain"/> entity.
     /// </summary>
@@ -41,6 +69,7 @@ public static DomainDto BuildDto(IDomain entity)
         var dto = new DomainDto
         {
             Id = entity.Id,
+            Key = entity.Key,
             DefaultLanguage = entity.LanguageId,
             RootStructureId = entity.RootContentId,
             DomainName = entity.DomainName,
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentTypeRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentTypeRepository.cs
index 844b7253d2d3..30b2764dfa6d 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentTypeRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentTypeRepository.cs
@@ -134,37 +134,16 @@ public IEnumerable<int> GetAllContentTypeIds(string[] aliases)
     protected override IRepositoryCachePolicy<IContentType, int> CreateCachePolicy() =>
         new FullDataSetRepositoryCachePolicy<IContentType, int>(GlobalIsolatedCache, ScopeAccessor, _repositoryCacheVersionService, _cacheSyncService, GetEntityId, /*expires:*/ true);
 
-    // every GetExists method goes cachePolicy.GetSomething which in turns goes PerformGetAll,
-    // since this is a FullDataSet policy - and everything is cached
-    // so here,
-    // every PerformGet/Exists just GetMany() and then filters
-    // except PerformGetAll which is the one really doing the job
-
-    // TODO: the filtering is highly inefficient as we deep-clone everything
-    // there should be a way to GetMany(predicate) right from the cache policy!
-    // and ah, well, this all caching should be refactored + the cache refreshers
-    // should to repository.Clear() not deal with magic caches by themselves
+    // Note: PerformGet(int) is passed as a callback to the cache policy's Get(TId) method,
+    // but FullDataSetRepositoryCachePolicy.Get() never invokes it — it uses GetAllCached()
+    // internally and clones only the matched entity. This override exists only as a required
+    // implementation of the abstract base and as a fallback for non-FullDataSet policies.
     protected override IContentType? PerformGet(int id)
         => GetMany().FirstOrDefault(x => x.Id == id);
 
-    protected override IContentType? PerformGet(Guid id)
-        => GetMany().FirstOrDefault(x => x.Key == id);
-
-    protected override IContentType? PerformGet(string alias)
-        => GetMany().FirstOrDefault(x => x.Alias.InvariantEquals(alias));
-
-    protected override bool PerformExists(Guid id)
-        => GetMany().FirstOrDefault(x => x.Key == id) != null;
-
     protected override IEnumerable<IContentType>? GetAllWithFullCachePolicy() =>
         CommonRepository.GetAllTypes()?.OfType<IContentType>();
 
-    protected override IEnumerable<IContentType> PerformGetAll(params Guid[]? ids)
-    {
-        IEnumerable<IContentType> all = GetMany();
-        return ids?.Any() ?? false ? all.Where(x => ids.Contains(x.Key)) : all;
-    }
-
     protected override IEnumerable<IContentType> PerformGetByQuery(IQuery<IContentType> query)
     {
         Sql<ISqlContext> baseQuery = GetBaseQuery(false);
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentTypeRepositoryBase.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentTypeRepositoryBase.cs
index 28e21af2de57..bfa2c638f389 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentTypeRepositoryBase.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentTypeRepositoryBase.cs
@@ -58,6 +58,13 @@ protected ContentTypeRepositoryBase(
 
     protected ILanguageRepository LanguageRepository { get; }
 
+    /// <summary>
+    /// Gets the cache policy as <see cref="FullDataSetRepositoryCachePolicy{TEntity, TId}"/> for predicate-based lookups.
+    /// Returns null if the repository uses a different cache policy type.
+    /// </summary>
+    protected FullDataSetRepositoryCachePolicy<TEntity, int>? TypedCachePolicy
+        => CachePolicy as FullDataSetRepositoryCachePolicy<TEntity, int>;
+
     protected abstract bool SupportsPublishing { get; }
 
     /// <summary>
@@ -1560,7 +1567,20 @@ protected void ValidateAlias(TEntity entity)
         }
     }
 
-    protected abstract TEntity? PerformGet(Guid id);
+    /// <summary>
+    /// Gets a content type by its unique key (GUID), using the full-dataset cache policy
+    /// to clone only the matched entity rather than the entire cached collection.
+    /// </summary>
+    protected virtual TEntity? PerformGet(Guid id)
+    {
+        if (TypedCachePolicy is { } policy)
+        {
+            return policy.FindCached(x => x.Key == id, PerformGetAll);
+        }
+
+        // Fallback for non-FullDataSet policies.
+        return GetMany().FirstOrDefault(x => x.Key == id);
+    }
 
     /// <summary>
     ///     Try to set the data type Id based on the provided key or property editor alias.
@@ -1616,11 +1636,65 @@ private void AssignDataTypeIdFromProvidedKeyOrPropertyEditor(IPropertyType prope
         }
     }
 
-    protected abstract TEntity? PerformGet(string alias);
+    /// <summary>
+    /// Gets a content type by its alias, using the full-dataset cache policy
+    /// to clone only the matched entity rather than the entire cached collection.
+    /// </summary>
+    protected virtual TEntity? PerformGet(string alias)
+    {
+        if (TypedCachePolicy is { } policy)
+        {
+            return policy.FindCached(x => x.Alias.InvariantEquals(alias), PerformGetAll);
+        }
+
+        // Fallback for non-FullDataSet policies.
+        return GetMany().FirstOrDefault(x => x.Alias.InvariantEquals(alias));
+    }
+
+    /// <summary>
+    /// Gets content types by their unique keys (GUIDs), using the full-dataset cache policy
+    /// to clone only the matched entities rather than the entire cached collection.
+    /// When <paramref name="ids"/> is null or empty, returns all content types.
+    /// </summary>
+    protected virtual IEnumerable<TEntity>? PerformGetAll(params Guid[]? ids)
+    {
+        if (TypedCachePolicy is { } policy)
+        {
+            if (ids?.Any() ?? false)
+            {
+                var idSet = ids.ToHashSet();
+                return policy.FindAllCached(x => idSet.Contains(x.Key), PerformGetAll);
+            }
+
+            // No filter — need all, clone everything (same as GetAll).
+            return policy.GetAll(null, PerformGetAll);
+        }
 
-    protected abstract IEnumerable<TEntity>? PerformGetAll(params Guid[]? ids);
+        // Fallback for non-FullDataSet policies.
+        IEnumerable<TEntity> all = GetMany();
+        if (ids?.Any() ?? false)
+        {
+            var idSet = ids.ToHashSet();
+            return all.Where(x => idSet.Contains(x.Key));
+        }
 
-    protected abstract bool PerformExists(Guid id);
+        return all;
+    }
+
+    /// <summary>
+    /// Checks whether a content type with the specified unique key (GUID) exists,
+    /// using the full-dataset cache policy to avoid any deep-cloning.
+    /// </summary>
+    protected virtual bool PerformExists(Guid id)
+    {
+        if (TypedCachePolicy is { } policy)
+        {
+            return policy.ExistsCached(x => x.Key == id, PerformGetAll);
+        }
+
+        // Fallback for non-FullDataSet policies.
+        return GetMany().Any(x => x.Key == id);
+    }
 
     /// <summary>
     /// Generates a unique alias for a content type by appending an incrementing number to the provided base alias if necessary.
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentVersionRepositoryBase.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentVersionRepositoryBase.cs
index 98e64c392a3b..bac66401589a 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentVersionRepositoryBase.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/ContentVersionRepositoryBase.cs
@@ -1,4 +1,4 @@
-using NPoco;
+using NPoco;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Infrastructure.Persistence.Dtos;
@@ -32,12 +32,7 @@ public ContentVersionRepositoryBase(IScopeAccessor scopeAccessor) =>
         _scopeAccessor = scopeAccessor ?? throw new ArgumentNullException(nameof(scopeAccessor));
 
     /// <inheritdoc />
-    /// <remarks>
-    ///     Never includes current draft version. <br />
-    ///     Never includes current published version.<br />
-    ///     Never includes versions marked as "preventCleanup".<br />
-    /// </remarks>
-    public IReadOnlyCollection<ContentVersionMeta> GetContentVersionsEligibleForCleanup()
+    public IReadOnlyCollection<ContentVersionMeta> GetContentVersionsEligibleForCleanup(DateTime olderThan, int? maxCount)
     {
         IScope? ambientScope = _scopeAccessor.AmbientScope;
         if (ambientScope is null)
@@ -59,7 +54,15 @@ public IReadOnlyCollection<ContentVersionMeta> GetContentVersionsEligibleForClea
             .On<UserDto, ContentVersionDto>(left => left.Id, right => right.UserId)
             .Where<ContentVersionDto>(x => !x.Current) // Never delete current draft version
             .Where<ContentVersionDto>(x => !x.PreventCleanup) // Never delete "pinned" versions
-            .Where<TContentVersionDto>(x => !x.Published); // Never delete published version
+            .Where<TContentVersionDto>(x => !x.Published) // Never delete published version
+            .Where<ContentVersionDto>(x => x.VersionDate < olderThan)
+            .OrderBy<ContentVersionDto>(x => x.VersionDate)
+            .OrderBy<ContentVersionDto>(x => x.Id);
+
+        if (maxCount.HasValue)
+        {
+            query = query.SelectTop(maxCount.Value);
+        }
 
         List<ContentVersionMeta> results = ambientScope.Database.Fetch<ContentVersionMeta>(query);
         EnsureUtcDates(results);
@@ -140,7 +143,10 @@ public IEnumerable<ContentVersionMeta> GetPagedItemsByContentId(int contentId, l
 
     /// <inheritdoc />
     /// <remarks>
-    ///     Deletes in batches of <see cref="Constants.Sql.MaxParameterCount" />
+    ///     Inserts version IDs into a temp table, then deletes from all related tables
+    ///     using a subquery join against the temp table. This is significantly faster than
+    ///     batched <c>WHERE IN (...)</c> for large sets, as the database engine can use
+    ///     indexed joins against the temp table's primary key.
     /// </remarks>
     public void DeleteVersions(IEnumerable<int> versionIds)
     {
@@ -149,34 +155,40 @@ public void DeleteVersions(IEnumerable<int> versionIds)
             return;
         }
 
-        foreach (IEnumerable<int> group in versionIds.InGroupsOf(Constants.Sql.MaxParameterCount))
+        var allIds = versionIds.ToList();
+        if (allIds.Count == 0)
+        {
+            return;
+        }
+
+        IDatabase db = _scopeAccessor.AmbientScope.Database;
+        ISqlSyntaxProvider syntax = _scopeAccessor.AmbientScope.SqlContext.SqlSyntax;
+
+        var tempTableName = "umbVersionsToDelete";
+        var quotedTempTableName = syntax.TempTableName(tempTableName);
+        try
+        {
+            db.Execute(syntax.CreateTempTable(tempTableName, $"{syntax.GetQuotedColumnName("Id")} INT NOT NULL PRIMARY KEY"));
+
+            // Batch insert IDs into the temp table.
+            foreach (IEnumerable<int> group in allIds.InGroupsOf(1000))
+            {
+                var batch = group.ToList();
+                var placeholders = string.Join(",", batch.Select((_, i) => $"(@{i})"));
+                db.Execute(
+                    $"INSERT INTO {quotedTempTableName} ({syntax.GetQuotedColumnName("Id")}) VALUES {placeholders}",
+                    batch.Cast<object>().ToArray());
+            }
+
+            // Delete from all related tables using a subquery against the temp table.
+            db.Execute($"DELETE FROM {syntax.GetQuotedTableName(PropertyDataDto.TableName)} WHERE {syntax.GetQuotedColumnName("versionId")} IN (SELECT {syntax.GetQuotedColumnName("Id")} FROM {quotedTempTableName})");
+            db.Execute($"DELETE FROM {syntax.GetQuotedTableName(ContentVersionCultureVariationDto.TableName)} WHERE {syntax.GetQuotedColumnName("versionId")} IN (SELECT {syntax.GetQuotedColumnName("Id")} FROM {quotedTempTableName})");
+            db.Execute($"DELETE FROM {syntax.GetQuotedTableName(ContentVersionDtoTableName)} WHERE {syntax.GetQuotedColumnName("id")} IN (SELECT {syntax.GetQuotedColumnName("Id")} FROM {quotedTempTableName})");
+            db.Execute($"DELETE FROM {syntax.GetQuotedTableName(ContentVersionDto.TableName)} WHERE {syntax.GetQuotedColumnName("id")} IN (SELECT {syntax.GetQuotedColumnName("Id")} FROM {quotedTempTableName})");
+        }
+        finally
         {
-            var groupedVersionIds = group.ToList();
-
-            /* Note: We had discussed doing this in a single SQL Command.
-            *  If you can work out how to make that work with SQL CE, let me know!
-            *  Can use test PerformContentVersionCleanup_WithNoKeepPeriods_DeletesEverythingExceptActive to try things out.
-            */
-
-            Sql<ISqlContext> query = _scopeAccessor.AmbientScope.SqlContext.Sql()
-                .Delete<PropertyDataDto>()
-                .WhereIn<PropertyDataDto>(x => x.VersionId, groupedVersionIds);
-            _scopeAccessor.AmbientScope.Database.Execute(query);
-
-            query = _scopeAccessor.AmbientScope.SqlContext.Sql()
-                .Delete<ContentVersionCultureVariationDto>()
-                .WhereIn<ContentVersionCultureVariationDto>(x => x.VersionId, groupedVersionIds);
-            _scopeAccessor.AmbientScope.Database.Execute(query);
-
-            query = _scopeAccessor.AmbientScope.SqlContext.Sql()
-                .Delete<TContentVersionDto>()
-                .WhereIn<TContentVersionDto>(x => x.Id, groupedVersionIds);
-            _scopeAccessor.AmbientScope.Database.Execute(query);
-
-            query = _scopeAccessor.AmbientScope.SqlContext.Sql()
-                .Delete<ContentVersionDto>()
-                .WhereIn<ContentVersionDto>(x => x.Id, groupedVersionIds);
-            _scopeAccessor.AmbientScope.Database.Execute(query);
+            db.Execute(syntax.DropTempTable(tempTableName));
         }
     }
 
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentUrlAliasRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentUrlAliasRepository.cs
index a1ebb6ccc5ca..8eb15aafba43 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentUrlAliasRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentUrlAliasRepository.cs
@@ -128,7 +128,7 @@ private PublishedDocumentUrlAlias BuildModel(DocumentUrlAliasDto dto) =>
         {
             Alias = dto.Alias,
             DocumentKey = dto.UniqueId,
-            NullableLanguageId = dto.LanguageId,
+            LanguageId = dto.LanguageId,
         };
 
     private DocumentUrlAliasDto BuildDto(PublishedDocumentUrlAlias model) =>
@@ -136,6 +136,6 @@ private DocumentUrlAliasDto BuildDto(PublishedDocumentUrlAlias model) =>
         {
             Alias = model.Alias,
             UniqueId = model.DocumentKey,
-            LanguageId = model.NullableLanguageId,
+            LanguageId = model.LanguageId,
         };
 }
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentUrlRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentUrlRepository.cs
index 0f4af80bf5f0..c821480eaf26 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentUrlRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DocumentUrlRepository.cs
@@ -47,10 +47,10 @@ public void Save(IEnumerable<PublishedDocumentUrlSegment> publishedDocumentUrlSe
 
         Dictionary<(Guid UniqueId, int? LanguageId, bool isDraft, string urlSegment), DocumentUrlDto> dtoDictionary = publishedDocumentUrlSegments
             .Select(BuildDto)
-            .ToDictionary(x => (x.UniqueId, x.NullableLanguageId, x.IsDraft, x.UrlSegment));
+            .ToDictionary(x => (x.UniqueId, x.LanguageId, x.IsDraft, x.UrlSegment));
 
         var toDelete = new List<int>();
-        var toInsert = dtoDictionary.Values.ToDictionary(x => (x.UniqueId, x.NullableLanguageId, x.IsDraft, x.UrlSegment));
+        var toInsert = dtoDictionary.Values.ToDictionary(x => (x.UniqueId, x.LanguageId, x.IsDraft, x.UrlSegment));
 
         foreach (IEnumerable<Guid> group in documentKeys.InGroupsOf(Constants.Sql.MaxParameterCount))
         {
@@ -64,12 +64,12 @@ public void Save(IEnumerable<PublishedDocumentUrlSegment> publishedDocumentUrlSe
 
             foreach (DocumentUrlDto existing in existingUrlsInBatch)
             {
-                if (dtoDictionary.TryGetValue((existing.UniqueId, existing.NullableLanguageId, existing.IsDraft, existing.UrlSegment), out DocumentUrlDto? found))
+                if (dtoDictionary.TryGetValue((existing.UniqueId, existing.LanguageId, existing.IsDraft, existing.UrlSegment), out DocumentUrlDto? found))
                 {
                     found.NodeId = existing.NodeId;
 
                     // If we found it, we know we should not insert it as a new record.
-                    toInsert.Remove((found.UniqueId, found.NullableLanguageId, found.IsDraft, found.UrlSegment));
+                    toInsert.Remove((found.UniqueId, found.LanguageId, found.IsDraft, found.UrlSegment));
                 }
                 else
                 {
@@ -117,7 +117,7 @@ private PublishedDocumentUrlSegment BuildModel(DocumentUrlDto dto) =>
         {
             UrlSegment = dto.UrlSegment,
             DocumentKey = dto.UniqueId,
-            NullableLanguageId = dto.NullableLanguageId,
+            LanguageId = dto.LanguageId,
             IsDraft = dto.IsDraft,
             IsPrimary = dto.IsPrimary
         };
@@ -128,7 +128,7 @@ private DocumentUrlDto BuildDto(PublishedDocumentUrlSegment model)
         {
             UrlSegment = model.UrlSegment,
             UniqueId = model.DocumentKey,
-            NullableLanguageId = model.NullableLanguageId,
+            LanguageId = model.LanguageId,
             IsDraft = model.IsDraft,
             IsPrimary = model.IsPrimary,
         };
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DomainRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DomainRepository.cs
index 37bf554ff6ae..ff50378bfb7d 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DomainRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/DomainRepository.cs
@@ -1,30 +1,24 @@
 using System.Data;
+using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
-using NPoco;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Cache;
 using Umbraco.Cms.Core.Models;
-using Umbraco.Cms.Core.Persistence.Querying;
 using Umbraco.Cms.Core.Persistence.Repositories;
-using Umbraco.Cms.Infrastructure.Persistence.Dtos;
+using Umbraco.Cms.Infrastructure.Cache;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos.EFCore;
+using Umbraco.Cms.Infrastructure.Persistence.EFCore;
+using Umbraco.Cms.Infrastructure.Persistence.EFCore.Scoping;
 using Umbraco.Cms.Infrastructure.Persistence.Factories;
-using Umbraco.Cms.Infrastructure.Scoping;
+using Umbraco.Cms.Infrastructure.Persistence.Repositories.Implement.EFCore;
 using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Infrastructure.Persistence.Repositories.Implement;
 
-internal sealed class DomainRepository : EntityRepositoryBase<int, IDomain>, IDomainRepository
+internal sealed class DomainRepository : AsyncEntityRepositoryBase<Guid, IDomain>, IDomainRepository
 {
-    /// <summary>
-    /// Initializes a new instance of the <see cref="DomainRepository"/> class.
-    /// </summary>
-    /// <param name="scopeAccessor">Provides access to the current database scope for repository operations.</param>
-    /// <param name="cache">The application-level caches used for optimizing data retrieval.</param>
-    /// <param name="logger">The logger used for logging repository events and errors.</param>
-    /// <param name="repositoryCacheVersionService">Service for managing cache versioning within the repository.</param>
-    /// <param name="cacheSyncService">Service responsible for synchronizing cache across distributed environments.</param>
     public DomainRepository(
-        IScopeAccessor scopeAccessor,
+        IEFCoreScopeAccessor<UmbracoDbContext> scopeAccessor,
         AppCaches cache,
         ILogger<DomainRepository> logger,
         IRepositoryCacheVersionService repositoryCacheVersionService,
@@ -38,195 +32,237 @@ public DomainRepository(
     {
     }
 
-    /// <summary>
-    /// Gets a domain by its name.
-    /// </summary>
-    /// <param name="domainName">The name of the domain to retrieve.</param>
-    /// <returns>The domain matching the specified name, or null if none found.</returns>
-    public IDomain? GetByName(string domainName)
-        => GetMany().FirstOrDefault(x => x.DomainName.InvariantEquals(domainName));
-
-    /// <summary>
-    /// Determines whether a domain with the specified name exists.
-    /// </summary>
-    /// <param name="domainName">The name of the domain to check for existence.</param>
-    /// <returns>True if the domain exists; otherwise, false.</returns>
-    public bool Exists(string domainName)
-        => GetMany().Any(x => x.DomainName.InvariantEquals(domainName));
-
-    /// <summary>
-    /// Gets all domains, optionally including wildcard domains.
-    /// </summary>
-    /// <param name="includeWildcards">If true, includes wildcard domains in the result; otherwise, excludes them.</param>
-    /// <returns>An enumerable collection of domains.</returns>
-    public IEnumerable<IDomain> GetAll(bool includeWildcards)
-        => GetMany().Where(x => includeWildcards || x.IsWildcard == false);
-
-    /// <summary>
-    /// Retrieves the domains assigned to the specified content item.
-    /// </summary>
-    /// <param name="contentId">The identifier of the content item for which to retrieve assigned domains.</param>
-    /// <param name="includeWildcards">If <c>true</c>, includes wildcard domains in the results; if <c>false</c>, only non-wildcard domains are returned.</param>
-    /// <returns>An <see cref="IEnumerable{IDomain}"/> containing the domains assigned to the specified content item.</returns>
-    public IEnumerable<IDomain> GetAssignedDomains(int contentId, bool includeWildcards)
-        => GetMany().Where(x => x.RootContentId == contentId).Where(x => includeWildcards || x.IsWildcard == false);
-
-    protected override IRepositoryCachePolicy<IDomain, int> CreateCachePolicy()
-        => new FullDataSetRepositoryCachePolicy<IDomain, int>(GlobalIsolatedCache, ScopeAccessor,  RepositoryCacheVersionService, CacheSyncService, GetEntityId, false);
-
-    protected override IDomain? PerformGet(int id)
-        // Use the underlying GetAll which will force cache all domains
-        => GetMany().FirstOrDefault(x => x.Id == id);
-
-    protected override IEnumerable<IDomain> PerformGetAll(params int[]? ids)
+    /// <inheritdoc/>
+    public async Task<IDomain?> GetByNameAsync(string domainName)
     {
-        Sql<ISqlContext> sql = GetBaseQuery(false).Where<DomainDto>(x => x.Id > 0);
-        if (ids?.Any() ?? false)
-        {
-            sql.WhereIn<DomainDto>(x => x.Id, ids);
-        }
-        sql.OrderBy<DomainDto>(dto => dto.SortOrder);
-
-        return Database.Fetch<DomainDto>(sql).Select(DomainFactory.BuildEntity);
+        IEnumerable<IDomain> all = await GetAllAsync(CancellationToken.None);
+        return all.FirstOrDefault(x => x.DomainName.InvariantEquals(domainName));
     }
 
-    protected override IEnumerable<IDomain> PerformGetByQuery(IQuery<IDomain> query)
-        => throw new NotSupportedException("This repository does not support this method");
+    /// <inheritdoc/>
+    public async Task<bool> ExistsAsync(string domainName)
+    {
+        IEnumerable<IDomain> all = await GetAllAsync(CancellationToken.None);
+        return all.Any(x => x.DomainName.InvariantEquals(domainName));
+    }
 
-    protected override Sql<ISqlContext> GetBaseQuery(bool isCount)
+    /// <inheritdoc/>
+    public async Task<IEnumerable<IDomain>> GetAllAsync(bool includeWildcards)
     {
-        Sql<ISqlContext> sql = Sql();
-        if (isCount)
-        {
-            sql.SelectCount().From<DomainDto>();
-        }
-        else
-        {
-            sql.Select($"{QuoteTableName(Constants.DatabaseSchema.Tables.Domain)}.*, {QuoteTableName(Constants.DatabaseSchema.Tables.Language)}.{QuoteColumnName("languageISOCode")}")
-                .From<DomainDto>()
-                .LeftJoin<LanguageDto>()
-                .On<DomainDto, LanguageDto>(dto => dto.DefaultLanguage, dto => dto.Id);
-        }
+        IEnumerable<IDomain> all = await GetAllAsync(CancellationToken.None);
+        return all.Where(x => includeWildcards || x.IsWildcard == false);
+    }
 
-        return sql;
+    /// <inheritdoc/>
+    public async Task<IEnumerable<IDomain>> GetAssignedDomainsAsync(Guid contentKey, bool includeWildcards)
+    {
+        IEnumerable<IDomain> all = await GetAllAsync(CancellationToken.None);
+        return all
+            .Where(x => x.RootContentKey == contentKey)
+            .Where(x => includeWildcards || x.IsWildcard == false);
     }
 
-    protected override string GetBaseWhereClause()
-        => $"{QuoteTableName(Constants.DatabaseSchema.Tables.Domain)}.id = @id";
+    /// <inheritdoc/>
+    protected override IAsyncRepositoryCachePolicy<IDomain, Guid> CreateCachePolicy()
+        => new AsyncFullDataSetRepositoryCachePolicy<IDomain, Guid>(GlobalIsolatedCache, ScopeAccessor, RepositoryCacheVersionService, CacheSyncService, entity => entity.Key, false);
+
+    /// <inheritdoc/>
+    protected override async Task<IDomain?> PerformGetAsync(Guid key)
+    {
+        // Use the underlying GetAll which will force cache all domains
+        IEnumerable<IDomain> all = await GetAllAsync(CancellationToken.None);
+        return all.FirstOrDefault(x => x.Key == key);
+    }
 
-    protected override IEnumerable<string> GetDeleteClauses()
-        => new []
+    /// <inheritdoc/>
+    protected override async Task<IEnumerable<IDomain>?> PerformGetAllAsync() =>
+        await AmbientScope.ExecuteWithContextAsync(async db =>
         {
-            $"DELETE FROM {QuoteTableName(Constants.DatabaseSchema.Tables.Domain)} WHERE id = @id",
-        };
+            List<DomainDto> dtos = await db.Domains
+                .OrderBy(x => x.SortOrder)
+                .ToListAsync();
+
+            return await BuildEntitiesAsync(db, dtos);
+        });
 
-    protected override void PersistNewItem(IDomain entity)
+    /// <inheritdoc/>
+    protected override async Task<IEnumerable<IDomain>?> PerformGetManyAsync(Guid[]? keys)
     {
-        var exists = Database.ExecuteScalar<int>(
-            $"SELECT COUNT(*) FROM {QuoteTableName(Constants.DatabaseSchema.Tables.Domain)} WHERE {QuoteColumnName("domainName")} = @domainName",
-            new { domainName = entity.DomainName });
-        if (exists > 0)
+        if (keys is null || keys.Length == 0)
         {
-            throw new DuplicateNameException($"The domain name {entity.DomainName} is already assigned.");
+            return null;
         }
 
-        if (entity.RootContentId.HasValue)
+        return await AmbientScope.ExecuteWithContextAsync(async db =>
         {
-            var contentExists = Database.ExecuteScalar<int>(
-                $"SELECT COUNT(*) FROM {QuoteTableName(Constants.DatabaseSchema.Tables.Content)} WHERE {QuoteColumnName("nodeId")} = @id",
-                new { id = entity.RootContentId.Value });
-            if (contentExists == 0)
-            {
-                throw new NullReferenceException($"No content exists with id {entity.RootContentId.Value}.");
-            }
-        }
+            List<DomainDto> dtos = await db.Domains
+                .Where(x => keys.Contains(x.Key))
+                .OrderBy(x => x.SortOrder)
+                .ToListAsync();
 
-        if (entity.LanguageId.HasValue)
+            return await BuildEntitiesAsync(db, dtos);
+        });
+    }
+
+    /// <inheritdoc/>
+    protected override async Task PersistNewItemAsync(IDomain entity) =>
+        await AmbientScope.ExecuteWithContextAsync<DomainDto>(async db =>
         {
-            var languageExists = Database.ExecuteScalar<int>(
-                $"SELECT COUNT(*) FROM {QuoteTableName(Constants.DatabaseSchema.Tables.Language)} WHERE id = @id",
-                new { id = entity.LanguageId.Value });
-            if (languageExists == 0)
+            // Check duplicate domain name
+            var exists = await db.Domains.AnyAsync(x => x.DomainName == entity.DomainName);
+            if (exists)
             {
-                throw new NullReferenceException($"No language exists with id {entity.LanguageId.Value}.");
+                throw new DuplicateNameException($"The domain name {entity.DomainName} is already assigned.");
             }
-        }
 
-        entity.AddingEntity();
+            // Validate RootContentId exists
+            if (entity.RootContentId.HasValue)
+            {
+                var contentExists = await db.Nodes.AnyAsync(x => x.NodeId == entity.RootContentId.Value);
+                if (!contentExists)
+                {
+                    throw new NullReferenceException($"No content exists with id {entity.RootContentId.Value}.");
+                }
+            }
 
-        // Get sort order
-        entity.SortOrder = GetNewSortOrder(entity.RootContentId, entity.IsWildcard);
+            // Validate LanguageId exists
+            if (entity.LanguageId.HasValue)
+            {
+                var languageExists = await db.Language.AnyAsync(x => x.Id == entity.LanguageId.Value);
+                if (!languageExists)
+                {
+                    throw new NullReferenceException($"No language exists with id {entity.LanguageId.Value}.");
+                }
+            }
 
-        DomainDto dto = DomainFactory.BuildDto(entity);
+            entity.AddingEntity();
+            entity.SortOrder = await GetNewSortOrderAsync(db, entity.RootContentId, entity.IsWildcard);
 
-        var id = Convert.ToInt32(Database.Insert(dto));
-        entity.Id = id;
+            DomainDto dto = DomainFactory.BuildDto(entity);
+            db.Domains.Add(dto);
+            await db.SaveChangesAsync();
 
-        // If the language changed, we need to resolve the ISO code
-        if (entity.LanguageId.HasValue)
-        {
-            ((UmbracoDomain)entity).LanguageIsoCode = Database.ExecuteScalar<string>(
-                $"SELECT {QuoteColumnName("languageISOCode")} FROM {QuoteTableName(Constants.DatabaseSchema.Tables.Language)} WHERE id = @langId",
-                new { langId = entity.LanguageId });
-        }
+            entity.Id = dto.Id;
 
-        entity.ResetDirtyProperties();
-    }
+            // Resolve ISO code
+            if (entity.LanguageId.HasValue)
+            {
+                LanguageDto? lang = await db.Language.FirstOrDefaultAsync(x => x.Id == entity.LanguageId.Value);
+                ((UmbracoDomain)entity).LanguageIsoCode = lang?.IsoCode;
+            }
 
-    protected override void PersistUpdatedItem(IDomain entity)
-    {
-        entity.UpdatingEntity();
+            entity.ResetDirtyProperties();
+        });
 
-        // Ensure there is no other domain with the same name on another entity
-        var exists = Database.ExecuteScalar<int>(
-            $"SELECT COUNT(*) FROM {QuoteTableName(Constants.DatabaseSchema.Tables.Domain)} WHERE {QuoteColumnName("domainName")} = @domainName AND id <> @id",
-            new { domainName = entity.DomainName, id = entity.Id });
-        if (exists > 0)
+    /// <inheritdoc/>
+    protected override async Task PersistUpdatedItemAsync(IDomain entity) =>
+        await AmbientScope.ExecuteWithContextAsync<DomainDto>(async db =>
         {
-            throw new DuplicateNameException($"The domain name {entity.DomainName} is already assigned.");
-        }
+            entity.UpdatingEntity();
 
-        if (entity.RootContentId.HasValue)
-        {
-            var contentExists = Database.ExecuteScalar<int>(
-                $"SELECT COUNT(*) FROM {QuoteTableName(Constants.DatabaseSchema.Tables.Content)} WHERE {QuoteColumnName("nodeId")} = @id",
-                new { id = entity.RootContentId.Value });
-            if (contentExists == 0)
+            // Check duplicate domain name (excluding self)
+            var exists = await db.Domains.AnyAsync(x => x.DomainName == entity.DomainName && x.Id != entity.Id);
+            if (exists)
             {
-                throw new NullReferenceException($"No content exists with id {entity.RootContentId.Value}.");
+                throw new DuplicateNameException($"The domain name {entity.DomainName} is already assigned.");
             }
-        }
 
-        if (entity.LanguageId.HasValue)
-        {
-            var languageExists = Database.ExecuteScalar<int>(
-                $"SELECT COUNT(*) FROM {QuoteTableName(Constants.DatabaseSchema.Tables.Language)} WHERE id = @id",
-                new { id = entity.LanguageId.Value });
-            if (languageExists == 0)
+            // Validate RootContentId exists
+            if (entity.RootContentId.HasValue)
             {
-                throw new NullReferenceException($"No language exists with id {entity.LanguageId.Value}.");
+                var contentExists = await db.Nodes.AnyAsync(x => x.NodeId == entity.RootContentId.Value);
+                if (!contentExists)
+                {
+                    throw new NullReferenceException($"No content exists with id {entity.RootContentId.Value}.");
+                }
+            }
+
+            // Validate LanguageId exists
+            if (entity.LanguageId.HasValue)
+            {
+                var languageExists = await db.Language.AnyAsync(x => x.Id == entity.LanguageId.Value);
+                if (!languageExists)
+                {
+                    throw new NullReferenceException($"No language exists with id {entity.LanguageId.Value}.");
+                }
             }
-        }
 
-        DomainDto dto = DomainFactory.BuildDto(entity);
+            DomainDto dto = DomainFactory.BuildDto(entity);
 
-        Database.Update(dto);
+            await db.Domains
+                .Where(x => x.Id == dto.Id)
+                .ExecuteUpdateAsync(setter => setter
+                    .SetProperty(x => x.Key, dto.Key)
+                    .SetProperty(x => x.DomainName, dto.DomainName)
+                    .SetProperty(x => x.DefaultLanguage, dto.DefaultLanguage)
+                    .SetProperty(x => x.RootStructureId, dto.RootStructureId)
+                    .SetProperty(x => x.SortOrder, dto.SortOrder));
 
-        // If the language changed, we need to resolve the ISO code
-        if (entity.WasPropertyDirty("LanguageId"))
+            // Resolve ISO code if language changed
+            if (entity.WasPropertyDirty("LanguageId"))
+            {
+                LanguageDto? lang = await db.Language.FirstOrDefaultAsync(x => x.Id == entity.LanguageId);
+                ((UmbracoDomain)entity).LanguageIsoCode = lang?.IsoCode;
+            }
+
+            entity.ResetDirtyProperties();
+        });
+
+    /// <inheritdoc/>
+    protected override async Task PersistDeletedItemAsync(IDomain entity)
+    {
+        await AmbientScope.ExecuteWithContextAsync(async db =>
+        {
+            await db.Domains.Where(x => x.Id == entity.Id).ExecuteDeleteAsync();
+            return true;
+        });
+    }
+
+    /// <inheritdoc/>
+    protected override Task<bool> PerformExistsAsync(Guid key) =>
+        AmbientScope.ExecuteWithContextAsync(db => db.Domains.AnyAsync(x => x.Key == key));
+
+    private static async Task<IEnumerable<IDomain>> BuildEntitiesAsync(UmbracoDbContext db, List<DomainDto> dtos)
+    {
+        // Batch-load language ISO codes
+        var languageIds = dtos
+            .Where(d => d.DefaultLanguage.HasValue)
+            .Select(d => d.DefaultLanguage!.Value)
+            .Distinct()
+            .ToList();
+
+        Dictionary<int, string> isoCodeLookup = await db.Language
+            .Where(l => languageIds.Contains(l.Id))
+            .Select(l => new { l.Id, l.IsoCode })
+            .ToDictionaryAsync(l => l.Id, l => l.IsoCode!);
+
+        var nodeIds = dtos
+            .Where(d => d.RootStructureId.HasValue)
+            .Select(d => d.RootStructureId!.Value)
+            .Distinct()
+            .ToList();
+
+        Dictionary<int, Guid> nodeKeyLookup = await db.Nodes
+            .Where(n => nodeIds.Contains(n.NodeId))
+            .Select(n => new { n.NodeId, n.UniqueId })
+            .ToDictionaryAsync(n => n.NodeId, n => n.UniqueId);
+
+        return DomainFactory.BuildEntities(dtos, isoCodeLookup, nodeKeyLookup);
+    }
+
+    private static async Task<int> GetNewSortOrderAsync(UmbracoDbContext db, int? rootContentId, bool isWildcard)
+    {
+        if (isWildcard)
         {
-            ((UmbracoDomain)entity).LanguageIsoCode = Database.ExecuteScalar<string>(
-                $"SELECT {QuoteColumnName("languageISOCode")} FROM {QuoteTableName(Constants.DatabaseSchema.Tables.Language)} WHERE id = @langId",
-                new { langId = entity.LanguageId });
+            return -1;
         }
 
-        entity.ResetDirtyProperties();
+        var maxSortOrder = await db.Domains
+            .Where(x => x.RootStructureId == rootContentId)
+            .Where(x => x.DomainName != string.Empty && !x.DomainName.StartsWith("*"))
+            .MaxAsync(x => (int?)x.SortOrder) ?? -1;
+
+        return maxSortOrder + 1;
     }
 
-    private int GetNewSortOrder(int? rootContentId, bool isWildcard)
-        => isWildcard
-        ? -1
-        : Database.ExecuteScalar<int>(
-            $"SELECT COALESCE(MAX({QuoteColumnName("sortOrder")}), -1) + 1 FROM {QuoteTableName(Constants.DatabaseSchema.Tables.Domain)} WHERE {QuoteColumnName("domainRootStructureID")} = @rootContentId AND NOT ({QuoteColumnName("domainName")} = '' OR {QuoteColumnName("domainName")} LIKE '*%')",
-            new { rootContentId });
 }
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/EFCore/AsyncRepositoryBase.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/EFCore/AsyncRepositoryBase.cs
index e35f1c87dfe5..51494086bd40 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/EFCore/AsyncRepositoryBase.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/EFCore/AsyncRepositoryBase.cs
@@ -27,11 +27,11 @@ public AsyncRepositoryBase(IEFCoreScopeAccessor<UmbracoDbContext> scopeAccessor,
     /// <summary>
     ///     Gets the AmbientScope
     /// </summary>
-    protected IEfCoreScope<UmbracoDbContext> AmbientScope
+    protected IEFCoreScope<UmbracoDbContext> AmbientScope
     {
         get
         {
-            IEfCoreScope<UmbracoDbContext>? scope = ScopeAccessor.AmbientScope;
+            IEFCoreScope<UmbracoDbContext>? scope = ScopeAccessor.AmbientScope;
             if (scope == null)
             {
                 throw new InvalidOperationException("Cannot run a repository without an ambient scope.");
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/LanguageRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/LanguageRepository.cs
index e382d71be8d2..39f9b9e41828 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/LanguageRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/LanguageRepository.cs
@@ -323,7 +323,7 @@ await db.Language
 
             // insert
             LanguageDto dto = LanguageFactory.BuildDto(entity, GetFallbackLanguageId(entity));
-            await db.Language.AddAsync(dto);
+            db.Language.Add(dto);
             await db.SaveChangesAsync();
 
             entity.Id = dto.Id;
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MediaTypeRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MediaTypeRepository.cs
index c77d7e00d1c6..e95ba9087879 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MediaTypeRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MediaTypeRepository.cs
@@ -66,32 +66,16 @@ public MediaTypeRepository(
     protected override IRepositoryCachePolicy<IMediaType, int> CreateCachePolicy() =>
         new FullDataSetRepositoryCachePolicy<IMediaType, int>(GlobalIsolatedCache, ScopeAccessor,  _repositoryCacheVersionService, _cacheSyncService, GetEntityId, /*expires:*/ true);
 
-    // every GetExists method goes cachePolicy.GetSomething which in turns goes PerformGetAll,
-    // since this is a FullDataSet policy - and everything is cached
-    // so here,
-    // every PerformGet/Exists just GetMany() and then filters
-    // except PerformGetAll which is the one really doing the job
+    // Note: PerformGet(int) is passed as a callback to the cache policy's Get(TId) method,
+    // but FullDataSetRepositoryCachePolicy.Get() never invokes it — it uses GetAllCached()
+    // internally and clones only the matched entity. This override exists only as a required
+    // implementation of the abstract base and as a fallback for non-FullDataSet policies.
     protected override IMediaType? PerformGet(int id)
         => GetMany().FirstOrDefault(x => x.Id == id);
 
-    protected override IMediaType? PerformGet(Guid id)
-        => GetMany().FirstOrDefault(x => x.Key == id);
-
-    protected override bool PerformExists(Guid id)
-        => GetMany().FirstOrDefault(x => x.Key == id) != null;
-
-    protected override IMediaType? PerformGet(string alias)
-        => GetMany().FirstOrDefault(x => x.Alias.InvariantEquals(alias));
-
     protected override IEnumerable<IMediaType>? GetAllWithFullCachePolicy() =>
         CommonRepository.GetAllTypes()?.OfType<IMediaType>();
 
-    protected override IEnumerable<IMediaType> PerformGetAll(params Guid[]? ids)
-    {
-        IEnumerable<IMediaType> all = GetMany();
-        return ids?.Any() ?? false ? all.Where(x => ids.Contains(x.Key)) : all;
-    }
-
     protected override IEnumerable<IMediaType> PerformGetByQuery(IQuery<IMediaType> query)
     {
         Sql<ISqlContext> baseQuery = GetBaseQuery(false);
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MemberRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MemberRepository.cs
index 07452960c541..a193588deac4 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MemberRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MemberRepository.cs
@@ -1,9 +1,11 @@
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using NPoco;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Cache;
 using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Membership;
@@ -33,11 +35,11 @@ public class MemberRepository : ContentRepositoryBase<int, IMember, MemberReposi
     private readonly MemberRepositoryUsernameCachePolicy _memberByUsernameCachePolicy;
     private readonly IMemberGroupRepository _memberGroupRepository;
     private readonly IMemberTypeRepository _memberTypeRepository;
-    private readonly MemberPasswordConfigurationSettings _passwordConfiguration;
     private readonly IPasswordHasher _passwordHasher;
     private readonly ITagRepository _tagRepository;
     private bool _passwordConfigInitialized;
     private string? _passwordConfigJson;
+    private readonly SecuritySettings _securitySettings;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="Umbraco.Cms.Infrastructure.Persistence.Repositories.Implement.MemberRepository"/> class.
@@ -57,9 +59,10 @@ public class MemberRepository : ContentRepositoryBase<int, IMember, MemberReposi
     /// <param name="dataTypeService">Service for managing data types.</param>
     /// <param name="serializer">The JSON serializer instance.</param>
     /// <param name="eventAggregator">Service for publishing and subscribing to events.</param>
-    /// <param name="passwordConfiguration">Configuration settings for member passwords.</param>
     /// <param name="repositoryCacheVersionService">Service for managing repository cache versions.</param>
     /// <param name="cacheSyncService">Service for synchronizing cache across servers.</param>
+    /// <param name="securitySettings">Configuration settings for member passwords.</param>
+    [ActivatorUtilitiesConstructor]
     public MemberRepository(
         IScopeAccessor scopeAccessor,
         AppCaches cache,
@@ -76,9 +79,9 @@ public MemberRepository(
         IDataTypeService dataTypeService,
         IJsonSerializer serializer,
         IEventAggregator eventAggregator,
-        IOptions<MemberPasswordConfigurationSettings> passwordConfiguration,
         IRepositoryCacheVersionService repositoryCacheVersionService,
-        ICacheSyncService cacheSyncService)
+        ICacheSyncService cacheSyncService,
+        IOptions<SecuritySettings> securitySettings)
         : base(
             scopeAccessor,
             cache,
@@ -99,11 +102,74 @@ public MemberRepository(
         _passwordHasher = passwordHasher;
         _jsonSerializer = serializer;
         _memberGroupRepository = memberGroupRepository;
-        _passwordConfiguration = passwordConfiguration.Value;
+        _securitySettings = securitySettings.Value;
         _memberByUsernameCachePolicy =
             new MemberRepositoryUsernameCachePolicy(GlobalIsolatedCache, ScopeAccessor, DefaultOptions, repositoryCacheVersionService, cacheSyncService);
     }
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="Umbraco.Cms.Infrastructure.Persistence.Repositories.Implement.MemberRepository"/> class.
+    /// </summary>
+    /// <param name="scopeAccessor">Provides access to the current database scope.</param>
+    /// <param name="cache">The application-level cache manager.</param>
+    /// <param name="logger">The logger used for diagnostic and error messages.</param>
+    /// <param name="memberTypeRepository">Repository for member types.</param>
+    /// <param name="memberGroupRepository">Repository for member groups.</param>
+    /// <param name="tagRepository">Repository for tags.</param>
+    /// <param name="languageRepository">Repository for languages.</param>
+    /// <param name="relationRepository">Repository for relations.</param>
+    /// <param name="relationTypeRepository">Repository for relation types.</param>
+    /// <param name="passwordHasher">Service for hashing passwords.</param>
+    /// <param name="propertyEditors">Collection of property editors.</param>
+    /// <param name="dataValueReferenceFactories">Collection of data value reference factories.</param>
+    /// <param name="dataTypeService">Service for managing data types.</param>
+    /// <param name="serializer">The JSON serializer instance.</param>
+    /// <param name="eventAggregator">Service for publishing and subscribing to events.</param>
+    /// <param name="passwordConfiguration">Configuration settings for member passwords.</param>
+    /// <param name="repositoryCacheVersionService">Service for managing repository cache versions.</param>
+    /// <param name="cacheSyncService">Service for synchronizing cache across servers.</param>
+    [Obsolete("Please use the constructor overload with all parameters. Scheduled for removal in Umbraco 19.")]
+    public MemberRepository(
+        IScopeAccessor scopeAccessor,
+        AppCaches cache,
+        ILogger<MemberRepository> logger,
+        IMemberTypeRepository memberTypeRepository,
+        IMemberGroupRepository memberGroupRepository,
+        ITagRepository tagRepository,
+        ILanguageRepository languageRepository,
+        IRelationRepository relationRepository,
+        IRelationTypeRepository relationTypeRepository,
+        IPasswordHasher passwordHasher,
+        PropertyEditorCollection propertyEditors,
+        DataValueReferenceFactoryCollection dataValueReferenceFactories,
+        IDataTypeService dataTypeService,
+        IJsonSerializer serializer,
+        IEventAggregator eventAggregator,
+        IOptions<MemberPasswordConfigurationSettings> passwordConfiguration,
+        IRepositoryCacheVersionService repositoryCacheVersionService,
+        ICacheSyncService cacheSyncService)
+        : this (
+            scopeAccessor,
+            cache,
+            logger,
+            memberTypeRepository,
+            memberGroupRepository,
+            tagRepository,
+            languageRepository,
+            relationRepository,
+            relationTypeRepository,
+            passwordHasher,
+            propertyEditors,
+            dataValueReferenceFactories,
+            dataTypeService,
+            serializer,
+            eventAggregator,
+            repositoryCacheVersionService,
+            cacheSyncService,
+            StaticServiceProvider.Instance.GetRequiredService<IOptions<SecuritySettings>>())
+    {
+    }
+
     /// <summary>
     ///     Returns a serialized dictionary of the password configuration that is stored against the member in the database
     /// </summary>
@@ -118,7 +184,7 @@ private string? DefaultPasswordConfigJson
 
             var passwordConfig = new PersistedPasswordSettings
             {
-                HashAlgorithm = _passwordConfiguration.HashAlgorithmType
+                HashAlgorithm = _securitySettings.MemberPassword.HashAlgorithmType
             };
 
             _passwordConfigJson = passwordConfig == null ? null : _jsonSerializer.Serialize(passwordConfig);
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MemberTypeRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MemberTypeRepository.cs
index b59f23de657f..7cfa74314205 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MemberTypeRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/MemberTypeRepository.cs
@@ -71,29 +71,13 @@ public MemberTypeRepository(
     protected override IRepositoryCachePolicy<IMemberType, int> CreateCachePolicy() =>
         new FullDataSetRepositoryCachePolicy<IMemberType, int>(GlobalIsolatedCache, ScopeAccessor,  _repositoryCacheVersionService, _cacheSyncService, GetEntityId, /*expires:*/ true);
 
-    // every GetExists method goes cachePolicy.GetSomething which in turns goes PerformGetAll,
-    // since this is a FullDataSet policy - and everything is cached
-    // so here,
-    // every PerformGet/Exists just GetMany() and then filters
-    // except PerformGetAll which is the one really doing the job
+    // Note: PerformGet(int) is passed as a callback to the cache policy's Get(TId) method,
+    // but FullDataSetRepositoryCachePolicy.Get() never invokes it — it uses GetAllCached()
+    // internally and clones only the matched entity. This override exists only as a required
+    // implementation of the abstract base and as a fallback for non-FullDataSet policies.
     protected override IMemberType? PerformGet(int id)
         => GetMany().FirstOrDefault(x => x.Id == id);
 
-    protected override IMemberType? PerformGet(Guid id)
-        => GetMany().FirstOrDefault(x => x.Key == id);
-
-    protected override IEnumerable<IMemberType> PerformGetAll(params Guid[]? ids)
-    {
-        IEnumerable<IMemberType> all = GetMany();
-        return ids?.Any() ?? false ? all.Where(x => ids.Contains(x.Key)) : all;
-    }
-
-    protected override bool PerformExists(Guid id)
-        => GetMany().FirstOrDefault(x => x.Key == id) != null;
-
-    protected override IMemberType? PerformGet(string alias)
-        => GetMany().FirstOrDefault(x => x.Alias.InvariantEquals(alias));
-
     protected override IEnumerable<IMemberType>? GetAllWithFullCachePolicy() =>
         CommonRepository.GetAllTypes()?.OfType<IMemberType>();
 
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/PermissionRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/PermissionRepository.cs
index 67a6cba968ef..54d6960bdf59 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/PermissionRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/PermissionRepository.cs
@@ -182,9 +182,9 @@ public void ReplacePermissions(int groupId, ISet<string> permissions, params int
                 .WhereIn<UserGroup2GranularPermissionDto>(
                     x => x.UniqueId,
                     Sql()
-                        .Select<NodeDto>()
+                        .Select<NodeDto>(x => x.UniqueId)
                         .From<NodeDto>()
-                        .Where<NodeDto>(x => entityIds.Contains(x.NodeId)))
+                        .WhereIn<NodeDto>(x => x.NodeId, entityIds))
                 .WhereIn<UserGroup2GranularPermissionDto>(
                     x => x.UserGroupKey,
                     Sql()
@@ -195,8 +195,8 @@ public void ReplacePermissions(int groupId, ISet<string> permissions, params int
         // This is a poor man's solution to avoid breaking changes.. Sooner or later we should obsolete this method and take Guids as input.
         Guid userGroupKey = db.Fetch<Guid>(Sql().Select<UserGroupDto>(x => x.Key).From<UserGroupDto>()
             .Where<UserGroupDto>(x => x.Id == groupId)).SingleOrDefault();
-        var idToKey = db.Fetch<NodeDto>(Sql().Select<NodeDto>().From<NodeDto>()
-            .Where<NodeDto>(x => entityIds.Contains(x.NodeId))).ToDictionary(x=>x.NodeId, x=>x.UniqueId);
+        var idToKey = db.Fetch<NodeDto>(Sql().Select<NodeDto>(x => x.NodeId, x => x.UniqueId).From<NodeDto>()
+            .WhereIn<NodeDto>(x => x.NodeId, entityIds)).ToDictionary(x=>x.NodeId, x=>x.UniqueId);
 
         IEnumerable<UserGroup2GranularPermissionDto> toInsert =
             from entityId in entityIds
@@ -226,9 +226,9 @@ public void AssignPermission(int groupId, string permission, params int[] entity
                 .WhereIn<UserGroup2GranularPermissionDto>(
                     x => x.UniqueId,
                     Sql()
-                        .Select<NodeDto>()
+                        .Select<NodeDto>(x => x.UniqueId)
                         .From<NodeDto>()
-                        .Where<NodeDto>(x => entityIds.Contains(x.NodeId)))
+                        .WhereIn<NodeDto>(x => x.NodeId, entityIds))
                 .WhereIn<UserGroup2GranularPermissionDto>(
                     x => x.UserGroupKey,
                     Sql()
@@ -239,8 +239,8 @@ public void AssignPermission(int groupId, string permission, params int[] entity
         // This is a poor man's solution to avoid breaking changes.. Sooner or later we should obsolete this method and take Guids as input.
         var userGroupKey = db.Fetch<Guid>(Sql().Select<UserGroupDto>(x => x.Key).From<UserGroupDto>()
             .Where<UserGroupDto>(x => x.Id == groupId)).SingleOrDefault();
-        var idToKey = db.Fetch<NodeDto>(Sql().Select<NodeDto>().From<NodeDto>()
-            .Where<NodeDto>(x => entityIds.Contains(x.NodeId))).ToDictionary(x=>x.NodeId, x=>x.UniqueId);
+        var idToKey = db.Fetch<NodeDto>(Sql().Select<NodeDto>(x => x.NodeId, x => x.UniqueId).From<NodeDto>()
+            .WhereIn<NodeDto>(x => x.NodeId, entityIds)).ToDictionary(x=>x.NodeId, x=>x.UniqueId);
 
         var toInsert = entityIds.Select(e => new UserGroup2GranularPermissionDto()
                 {
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/UserRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/UserRepository.cs
index a15b729a6de8..e69fbc76c2c5 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/UserRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/UserRepository.cs
@@ -32,7 +32,7 @@ internal sealed class UserRepository : EntityRepositoryBase<Guid, IUser>, IUserR
 {
     private readonly IMapperCollection _mapperCollection;
     private readonly GlobalSettings _globalSettings;
-    private readonly UserPasswordConfigurationSettings _passwordConfiguration;
+    private readonly SecuritySettings _securitySettings;
     private readonly IJsonSerializer _jsonSerializer;
     private readonly IRuntimeState _runtimeState;
     private string? _passwordConfigJson;
@@ -48,7 +48,7 @@ internal sealed class UserRepository : EntityRepositoryBase<Guid, IUser>, IUserR
     /// <param name="logger">The logger.</param>
     /// <param name="mapperCollection">The mapper collection.</param>
     /// <param name="globalSettings">The global settings.</param>
-    /// <param name="passwordConfiguration">The password configuration.</param>
+    /// <param name="securitySettings">The password configuration.</param>
     /// <param name="jsonSerializer">The JSON serializer.</param>
     /// <param name="runtimeState">State of the runtime.</param>
     /// <param name="repositoryCacheVersionService">The repository cache version service.</param>
@@ -67,7 +67,7 @@ public UserRepository(
         ILogger<UserRepository> logger,
         IMapperCollection mapperCollection,
         IOptions<GlobalSettings> globalSettings,
-        IOptions<UserPasswordConfigurationSettings> passwordConfiguration,
+        IOptions<SecuritySettings> securitySettings,
         IJsonSerializer jsonSerializer,
         IRuntimeState runtimeState,
         IRepositoryCacheVersionService repositoryCacheVersionService,
@@ -82,8 +82,8 @@ public UserRepository(
     {
         _mapperCollection = mapperCollection ?? throw new ArgumentNullException(nameof(mapperCollection));
         _globalSettings = globalSettings.Value ?? throw new ArgumentNullException(nameof(globalSettings));
-        _passwordConfiguration =
-            passwordConfiguration.Value ?? throw new ArgumentNullException(nameof(passwordConfiguration));
+        _securitySettings =
+            securitySettings.Value ?? throw new ArgumentNullException(nameof(securitySettings));
         _jsonSerializer = jsonSerializer;
         _runtimeState = runtimeState;
         _permissionMappers = permissionMappers.ToDictionary(x => x.Context);
@@ -103,7 +103,7 @@ private string? DefaultPasswordConfigJson
 
             var passwordConfig = new PersistedPasswordSettings
             {
-                HashAlgorithm = _passwordConfiguration.HashAlgorithmType
+                HashAlgorithm = _securitySettings.UserPassword.HashAlgorithmType
             };
 
             _passwordConfigJson = passwordConfig == null ? null : _jsonSerializer.Serialize(passwordConfig);
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/WebhookRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/WebhookRepository.cs
index d4efde6dc0a4..548aa2bc2c04 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/WebhookRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/WebhookRepository.cs
@@ -33,7 +33,7 @@ public WebhookRepository(
     /// <returns>A task representing the asynchronous operation. The task result contains a <see cref="PagedModel{IWebhook}"/> with the requested webhooks and the total count.</returns>
     public async Task<PagedModel<IWebhook>> GetAllAsync(int skip, int take)
     {
-        IEfCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
+        IEFCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
                                                ?? throw new InvalidOperationException("No ambient EF Core scope is available.");
 
         List<WebhookDto> webhookDtos = await scope.ExecuteWithContextAsync<List<WebhookDto>>(async db =>
@@ -64,7 +64,7 @@ public async Task<PagedModel<IWebhook>> GetAllAsync(int skip, int take)
     /// </returns>
     public async Task<IWebhook> CreateAsync(IWebhook webhook)
     {
-        IEfCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
+        IEFCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
                                                ?? throw new InvalidOperationException("No ambient EF Core scope is available.");
 
         webhook.AddingEntity();
@@ -88,7 +88,7 @@ public async Task<IWebhook> CreateAsync(IWebhook webhook)
     /// <returns>A task that represents the asynchronous operation. The task result contains the webhook entity if found; otherwise, null.</returns>
     public async Task<IWebhook?> GetAsync(Guid key)
     {
-        IEfCoreScope<UmbracoDbContext>? scope = _scopeAccessor.AmbientScope;
+        IEFCoreScope<UmbracoDbContext>? scope = _scopeAccessor.AmbientScope;
         if (scope is null)
         {
             return null;
@@ -116,7 +116,7 @@ public async Task<IWebhook> CreateAsync(IWebhook webhook)
     /// </returns>
     public async Task<PagedModel<IWebhook>> GetByIdsAsync(IEnumerable<Guid> keys)
     {
-        IEfCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
+        IEFCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
                                                ?? throw new InvalidOperationException("No ambient EF Core scope is available.");
 
         List<WebhookDto> webhookDtos = await scope.ExecuteWithContextAsync<List<WebhookDto>>(async db =>
@@ -146,7 +146,7 @@ public async Task<PagedModel<IWebhook>> GetByIdsAsync(IEnumerable<Guid> keys)
     /// </returns>
     public async Task<PagedModel<IWebhook>> GetByAliasAsync(string alias)
     {
-        IEfCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
+        IEFCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
                                                 ?? throw new InvalidOperationException("No ambient EF Core scope is available.");
 
         List<WebhookDto> dtos = await scope.ExecuteWithContextAsync(async db =>
@@ -173,7 +173,7 @@ public async Task<PagedModel<IWebhook>> GetByAliasAsync(string alias)
     /// <returns>A task representing the asynchronous delete operation.</returns>
     public async Task DeleteAsync(IWebhook webhook)
     {
-        IEfCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
+        IEFCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
                                                 ?? throw new InvalidOperationException("No ambient EF Core scope is available.");
 
         await scope.ExecuteWithContextAsync<Task>(async db =>
@@ -189,7 +189,7 @@ await scope.ExecuteWithContextAsync<Task>(async db =>
     /// <returns>A task that represents the asynchronous update operation.</returns
     public async Task UpdateAsync(IWebhook webhook)
     {
-        IEfCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
+        IEFCoreScope<UmbracoDbContext> scope = _scopeAccessor.AmbientScope
             ?? throw new InvalidOperationException("No ambient EF Core scope is available.");
 
         webhook.UpdatingEntity();
diff --git a/src/Umbraco.Infrastructure/Persistence/SqlSyntax/ISqlSyntaxProvider.cs b/src/Umbraco.Infrastructure/Persistence/SqlSyntax/ISqlSyntaxProvider.cs
index 8b6bc16aa9f8..34936f2e072b 100644
--- a/src/Umbraco.Infrastructure/Persistence/SqlSyntax/ISqlSyntaxProvider.cs
+++ b/src/Umbraco.Infrastructure/Persistence/SqlSyntax/ISqlSyntaxProvider.cs
@@ -553,4 +553,31 @@ Sql<ISqlContext>.SqlJoinClause<ISqlContext> LeftJoinWithNestedJoin<TDto>(
     /// <param name="constraintName">unlimited name.</param>
     /// <returns>truncated name.</returns>
     string TruncateConstraintName<T>(string constraintName);
+
+    /// <summary>
+    /// Gets the SQL to create a temporary table with the given name and column definitions.
+    /// </summary>
+    /// <param name="tableName">The base name for the temporary table (without any provider-specific prefix).</param>
+    /// <param name="columnDefinitionSql">The SQL column definitions (e.g., "Id INT NOT NULL PRIMARY KEY").</param>
+    /// <returns>A SQL statement that creates the temporary table.</returns>
+    // TODO (V19): Remove default implementation.
+    string CreateTempTable(string tableName, string columnDefinitionSql)
+        => $"CREATE TEMP TABLE {tableName} ({columnDefinitionSql})";
+
+    /// <summary>
+    /// Gets the properly qualified name for a temporary table, applying any provider-specific prefix.
+    /// </summary>
+    /// <param name="baseName">The base name for the temporary table.</param>
+    /// <returns>The qualified temporary table name.</returns>
+    // TODO (V19): Remove default implementation.
+    string TempTableName(string baseName) => baseName;
+
+    /// <summary>
+    /// Gets the SQL to drop a temporary table if it exists.
+    /// </summary>
+    /// <param name="tableName">The base name for the temporary table (without any provider-specific prefix).</param>
+    /// <returns>A SQL statement that drops the temporary table if it exists.</returns>
+    // TODO (V19): Remove default implementation.
+    string DropTempTable(string tableName)
+        => $"DROP TABLE IF EXISTS {tableName}";
 }
diff --git a/src/Umbraco.Infrastructure/Persistence/SqlSyntax/SqlSyntaxProviderBase.cs b/src/Umbraco.Infrastructure/Persistence/SqlSyntax/SqlSyntaxProviderBase.cs
index 9e823cf2081d..5b758d8424f8 100644
--- a/src/Umbraco.Infrastructure/Persistence/SqlSyntax/SqlSyntaxProviderBase.cs
+++ b/src/Umbraco.Infrastructure/Persistence/SqlSyntax/SqlSyntaxProviderBase.cs
@@ -1161,4 +1161,15 @@ protected virtual string FormatDefaultValue(ColumnDefinition column)
 
     /// <inheritdoc />
     public virtual string TruncateConstraintName<T>(string constraintName) => constraintName;
+
+    /// <inheritdoc />
+    public virtual string CreateTempTable(string tableName, string columnDefinitionSql)
+        => $"CREATE TEMP TABLE {tableName} ({columnDefinitionSql})";
+
+    /// <inheritdoc />
+    public virtual string TempTableName(string baseName) => baseName;
+
+    /// <inheritdoc />
+    public virtual string DropTempTable(string tableName)
+        => $"DROP TABLE IF EXISTS {tableName}";
 }
diff --git a/src/Umbraco.Infrastructure/PropertyEditors/AllowedMediaTypeHelper.cs b/src/Umbraco.Infrastructure/PropertyEditors/AllowedMediaTypeHelper.cs
new file mode 100644
index 000000000000..d2c6faf70859
--- /dev/null
+++ b/src/Umbraco.Infrastructure/PropertyEditors/AllowedMediaTypeHelper.cs
@@ -0,0 +1,85 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using Umbraco.Cms.Core.Cache;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Core.PropertyEditors;
+
+/// <summary>
+/// Shared helper for checking whether a media type alias is among a set of allowed media type keys.
+/// Used by both RTE and MediaPicker3 allowed-type validators.
+/// </summary>
+internal sealed class AllowedMediaTypeHelper
+{
+    private const string MediaTypeCacheKeyFormat = nameof(AllowedMediaTypeHelper) + "_MediaTypeKey_{0}";
+
+    private readonly IMediaTypeService _mediaTypeService;
+    private readonly AppCaches _appCaches;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AllowedMediaTypeHelper"/> class.
+    /// </summary>
+    /// <param name="mediaTypeService">Service for media type lookups.</param>
+    /// <param name="appCaches">Application caches for request-level caching.</param>
+    public AllowedMediaTypeHelper(IMediaTypeService mediaTypeService, AppCaches appCaches)
+    {
+        _mediaTypeService = mediaTypeService;
+        _appCaches = appCaches;
+    }
+
+    /// <summary>
+    /// Checks whether a media type alias resolves to one of the allowed media type keys.
+    /// </summary>
+    /// <param name="typeAlias">The media type alias to check.</param>
+    /// <param name="allowedTypeKeys">The set of allowed media type keys (case-insensitive).</param>
+    /// <returns><c>true</c> if the alias resolves to an allowed key; otherwise <c>false</c>.</returns>
+    public bool IsAllowed(string typeAlias, HashSet<string> allowedTypeKeys)
+    {
+        var typeKey = GetMediaTypeKey(typeAlias);
+        return typeKey is not null && allowedTypeKeys.Contains(typeKey);
+    }
+
+    /// <summary>
+    /// Parses a comma-separated allowed types configuration string into a case-insensitive set of keys.
+    /// </summary>
+    /// <returns>
+    /// A case-insensitive set of allowed media type keys, or an empty set if the configuration is empty or
+    /// not set (meaning all types are allowed).
+    /// </returns>
+    public static HashSet<string> ParseAllowedTypeKeys(string? configValue)
+    {
+        var allowedTypes = configValue?.Split(Constants.CharArrays.Comma, StringSplitOptions.RemoveEmptyEntries);
+
+        if (allowedTypes is null || allowedTypes.Length == 0)
+        {
+            return [];
+        }
+
+        return new HashSet<string>(allowedTypes, StringComparer.OrdinalIgnoreCase);
+    }
+
+    private string? GetMediaTypeKey(string typeAlias)
+    {
+        string? GetMediaTypeKeyFromService(string alias) => _mediaTypeService.Get(alias)?.Key.ToString();
+
+        if (_appCaches.RequestCache.IsAvailable is false)
+        {
+            return GetMediaTypeKeyFromService(typeAlias);
+        }
+
+        var cacheKey = string.Format(MediaTypeCacheKeyFormat, typeAlias);
+        var typeKey = _appCaches.RequestCache.GetCacheItem<string?>(cacheKey);
+        if (typeKey is null)
+        {
+            typeKey = GetMediaTypeKeyFromService(typeAlias);
+            if (typeKey is not null)
+            {
+                _appCaches.RequestCache.Set(cacheKey, typeKey);
+            }
+        }
+
+        return typeKey;
+    }
+}
diff --git a/src/Umbraco.Infrastructure/PropertyEditors/MediaPicker3PropertyEditor.cs b/src/Umbraco.Infrastructure/PropertyEditors/MediaPicker3PropertyEditor.cs
index 86474fb082b5..b04b6231b545 100644
--- a/src/Umbraco.Infrastructure/PropertyEditors/MediaPicker3PropertyEditor.cs
+++ b/src/Umbraco.Infrastructure/PropertyEditors/MediaPicker3PropertyEditor.cs
@@ -247,7 +247,7 @@ public MediaPicker3PropertyValueEditor(
             var validators = new TypedJsonValidatorRunner<List<MediaWithCropsDto>, MediaPicker3Configuration>(
                 jsonSerializer,
                 new MinMaxValidator(localizedTextService),
-                new AllowedTypeValidator(localizedTextService, mediaTypeService, _mediaService, appCaches),
+                new AllowedTypeValidator(localizedTextService, _mediaService, new AllowedMediaTypeHelper(mediaTypeService, appCaches)),
                 new StartNodeValidator(localizedTextService, mediaNavigationQueryService));
 
             Validators.Add(validators);
@@ -575,22 +575,18 @@ public IEnumerable<ValidationResult> Validate(
         /// </summary>
         internal sealed class AllowedTypeValidator : ITypedJsonValidator<List<MediaWithCropsDto>, MediaPicker3Configuration>
         {
-            private const string MediaTypeCacheKeyFormat = nameof(AllowedTypeValidator) + "_MediaTypeKey_{0}";
-
             private readonly ILocalizedTextService _localizedTextService;
-            private readonly IMediaTypeService _mediaTypeService;
             private readonly IMediaService _mediaService;
-            private readonly AppCaches _appCaches;
+            private readonly AllowedMediaTypeHelper _allowedMediaTypeHelper;
 
             /// <summary>
             /// Initializes a new instance of the <see cref="AllowedTypeValidator"/> class.
             /// </summary>
-            public AllowedTypeValidator(ILocalizedTextService localizedTextService, IMediaTypeService mediaTypeService, IMediaService mediaService, AppCaches appCaches)
+            public AllowedTypeValidator(ILocalizedTextService localizedTextService, IMediaService mediaService, AllowedMediaTypeHelper allowedMediaTypeHelper)
             {
                 _localizedTextService = localizedTextService;
-                _mediaTypeService = mediaTypeService;
                 _mediaService = mediaService;
-                _appCaches = appCaches;
+                _allowedMediaTypeHelper = allowedMediaTypeHelper;
             }
 
             /// <inheritdoc/>
@@ -605,10 +601,10 @@ public IEnumerable<ValidationResult> Validate(
                     return [];
                 }
 
-                var allowedTypes = configuration.Filter?.Split(Constants.CharArrays.Comma, StringSplitOptions.RemoveEmptyEntries);
+                HashSet<string> allowedTypeKeys = AllowedMediaTypeHelper.ParseAllowedTypeKeys(configuration.Filter);
 
                 // No allowed types = all types are allowed
-                if (allowedTypes is null || allowedTypes.Length == 0)
+                if (allowedTypeKeys.Count == 0)
                 {
                     return [];
                 }
@@ -630,9 +626,7 @@ public IEnumerable<ValidationResult> Validate(
 
                 foreach (var typeAlias in distinctTypeAliases)
                 {
-                    string? typeKey = GetMediaTypeKey(typeAlias);
-
-                    if (typeKey is null || allowedTypes.Contains(typeKey) is false)
+                    if (_allowedMediaTypeHelper.IsAllowed(typeAlias, allowedTypeKeys) is false)
                     {
                         return
                         [
@@ -645,31 +639,6 @@ public IEnumerable<ValidationResult> Validate(
 
                 return [];
             }
-
-            private string? GetMediaTypeKey(string typeAlias)
-            {
-                // Cache media type lookups since the same media type is likely to be used multiple times in validation,
-                // particularly if we have multiple languages and blocks.
-                string? GetMediaTypeKeyFromService(string typeAlias) => _mediaTypeService.Get(typeAlias)?.Key.ToString();
-
-                if (_appCaches.RequestCache.IsAvailable is false)
-                {
-                    return GetMediaTypeKeyFromService(typeAlias);
-                }
-
-                var cacheKey = string.Format(MediaTypeCacheKeyFormat, typeAlias);
-                string? typeKey = _appCaches.RequestCache.GetCacheItem<string?>(cacheKey);
-                if (typeKey is null)
-                {
-                    typeKey = GetMediaTypeKeyFromService(typeAlias);
-                    if (typeKey is not null)
-                    {
-                        _appCaches.RequestCache.Set(cacheKey, typeKey);
-                    }
-                }
-
-                return typeKey;
-            }
         }
 
         /// <summary>
diff --git a/src/Umbraco.Infrastructure/PropertyEditors/NotificationHandlers/SvgFileUploadMediaSavingNotificationHandler.cs b/src/Umbraco.Infrastructure/PropertyEditors/NotificationHandlers/SvgFileUploadMediaSavingNotificationHandler.cs
new file mode 100644
index 000000000000..60fb905b18b4
--- /dev/null
+++ b/src/Umbraco.Infrastructure/PropertyEditors/NotificationHandlers/SvgFileUploadMediaSavingNotificationHandler.cs
@@ -0,0 +1,111 @@
+using System.Drawing;
+using Microsoft.Extensions.Logging;
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.IO;
+using Umbraco.Cms.Core.Media;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Notifications;
+
+namespace Umbraco.Cms.Infrastructure.PropertyEditors.NotificationHandlers;
+
+/// <summary>
+/// Notification handler to set width / height of uploaded SVG media.
+/// </summary>
+internal sealed class SvgFileUploadMediaSavingNotificationHandler : INotificationHandler<MediaSavingNotification>
+{
+    private readonly ILogger<SvgFileUploadMediaSavingNotificationHandler> _logger;
+    private readonly ISvgDimensionExtractor _svgDimensionExtractor;
+    private readonly MediaFileManager _mediaFileManager;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="SvgFileUploadMediaSavingNotificationHandler"/> class.
+    /// </summary>
+    public SvgFileUploadMediaSavingNotificationHandler(
+        ILogger<SvgFileUploadMediaSavingNotificationHandler> logger,
+        ISvgDimensionExtractor svgDimensionExtractor,
+        MediaFileManager mediaFileManager)
+    {
+        _logger = logger;
+        _svgDimensionExtractor = svgDimensionExtractor;
+        _mediaFileManager = mediaFileManager;
+    }
+
+    /// <inheritdoc/>
+    public void Handle(MediaSavingNotification notification)
+    {
+        foreach (IMedia entity in notification.SavedEntities)
+        {
+            if (entity.ContentType.Alias.Equals(Core.Constants.Conventions.MediaTypes.VectorGraphicsAlias) is false)
+            {
+                continue;
+            }
+
+            AutoFillSvgWidthHeight(entity);
+        }
+    }
+
+    private void AutoFillSvgWidthHeight(IContentBase model)
+    {
+        if (model.Properties.TryGetValue(Core.Constants.Conventions.Media.Width, out _) is false
+            || model.Properties.TryGetValue(Core.Constants.Conventions.Media.Height, out _) is false)
+        {
+            _logger.LogDebug("Skipping SVG dimension extraction for media {MediaId}: width/height properties not found on content type.", model.Id);
+            return;
+        }
+
+        IProperty? property = model.Properties
+            .FirstOrDefault(x => x.PropertyType.PropertyEditorAlias == Core.Constants.PropertyEditors.Aliases.UploadField);
+
+        if (property is null)
+        {
+            _logger.LogDebug("Skipping SVG dimension extraction for media {MediaId}: no upload field property found.", model.Id);
+            return;
+        }
+
+        foreach (IPropertyValue pvalue in property.Values)
+        {
+            var svalue = property.GetValue(pvalue.Culture, pvalue.Segment) as string;
+
+            if (string.IsNullOrWhiteSpace(svalue))
+            {
+                continue;
+            }
+
+            string filepath = _mediaFileManager.FileSystem.GetRelativePath(svalue);
+
+            if (_mediaFileManager.FileSystem.FileExists(filepath) is false)
+            {
+                _logger.LogWarning("SVG file not found at path {FilePath} for media {MediaId}.", filepath, model.Id);
+                continue;
+            }
+
+            using Stream filestream = _mediaFileManager.FileSystem.OpenFile(filepath);
+
+            SetWidthAndHeight(model, filestream, pvalue.Culture, pvalue.Segment);
+        }
+    }
+
+    private void SetWidthAndHeight(IContentBase model, Stream filestream, string? culture, string? segment)
+    {
+        Size? size = _svgDimensionExtractor.GetDimensions(filestream);
+        if (size.HasValue)
+        {
+            _logger.LogDebug("Extracted SVG dimensions {Width}x{Height} for media {MediaId}.", size.Value.Width, size.Value.Height, model.Id);
+            SetProperty(model, Core.Constants.Conventions.Media.Width, size.Value.Width, culture, segment);
+            SetProperty(model, Core.Constants.Conventions.Media.Height, size.Value.Height, culture, segment);
+        }
+        else
+        {
+            _logger.LogDebug("Could not extract dimensions from SVG for media {MediaId}.", model.Id);
+        }
+    }
+
+    private static void SetProperty(IContentBase content, string alias, object? value, string? culture, string? segment)
+    {
+        if (string.IsNullOrEmpty(alias) is false &&
+            content.Properties.TryGetValue(alias, out IProperty? property))
+        {
+            property.SetValue(value, culture, segment);
+        }
+    }
+}
diff --git a/src/Umbraco.Infrastructure/PropertyEditors/RichTextAllowedMediaTypeValidator.cs b/src/Umbraco.Infrastructure/PropertyEditors/RichTextAllowedMediaTypeValidator.cs
new file mode 100644
index 000000000000..0e64222ec136
--- /dev/null
+++ b/src/Umbraco.Infrastructure/PropertyEditors/RichTextAllowedMediaTypeValidator.cs
@@ -0,0 +1,94 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using System.ComponentModel.DataAnnotations;
+using Microsoft.Extensions.Logging;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Validation;
+using Umbraco.Cms.Core.Serialization;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Templates;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Core.PropertyEditors;
+
+/// <summary>
+/// Validates that media items referenced in RTE markup are of an allowed media type.
+/// </summary>
+internal sealed class RichTextAllowedMediaTypeValidator : IValueValidator
+{
+    private readonly HtmlImageSourceParser _imageSourceParser;
+    private readonly IMediaService _mediaService;
+    private readonly ILocalizedTextService _localizedTextService;
+    private readonly IJsonSerializer _jsonSerializer;
+    private readonly ILogger _logger;
+    private readonly AllowedMediaTypeHelper _allowedMediaTypeHelper;
+
+    public RichTextAllowedMediaTypeValidator(
+        HtmlImageSourceParser imageSourceParser,
+        IMediaService mediaService,
+        ILocalizedTextService localizedTextService,
+        IJsonSerializer jsonSerializer,
+        ILogger logger,
+        AllowedMediaTypeHelper allowedMediaTypeHelper)
+    {
+        _imageSourceParser = imageSourceParser;
+        _mediaService = mediaService;
+        _localizedTextService = localizedTextService;
+        _jsonSerializer = jsonSerializer;
+        _logger = logger;
+        _allowedMediaTypeHelper = allowedMediaTypeHelper;
+    }
+
+    /// <inheritdoc/>
+    public IEnumerable<ValidationResult> Validate(
+        object? value,
+        string? valueType,
+        object? dataTypeConfiguration,
+        PropertyValidationContext validationContext)
+    {
+        if (dataTypeConfiguration is not RichTextConfiguration configuration)
+        {
+            return [];
+        }
+
+        HashSet<string> allowedTypeKeys = AllowedMediaTypeHelper.ParseAllowedTypeKeys(configuration.AllowedMediaTypes);
+
+        // No allowed types configured = all types are allowed
+        if (allowedTypeKeys.Count == 0)
+        {
+            return [];
+        }
+
+        if (!RichTextPropertyEditorHelper.TryParseRichTextEditorValue(value, _jsonSerializer, _logger, out RichTextEditorValue? richTextEditorValue))
+        {
+            return [];
+        }
+
+        if (string.IsNullOrWhiteSpace(richTextEditorValue.Markup))
+        {
+            return [];
+        }
+
+        IEnumerable<Udi> udis = _imageSourceParser.FindUdisFromDataAttributes(richTextEditorValue.Markup);
+        Guid[] mediaKeys = udis.OfType<GuidUdi>().Select(udi => udi.Guid).Distinct().ToArray();
+
+        if (mediaKeys.Length == 0)
+        {
+            return [];
+        }
+
+        IEnumerable<IMedia> mediaItems = _mediaService.GetByIds(mediaKeys);
+
+        foreach (IMedia media in mediaItems)
+        {
+            if (_allowedMediaTypeHelper.IsAllowed(media.ContentType.Alias, allowedTypeKeys) is false)
+            {
+                var message = $"{_localizedTextService.Localize("validation", "invalidMediaType")}: '{media.Name}'";
+                return [new ValidationResult(message, ["value"])];
+            }
+        }
+
+        return [];
+    }
+}
diff --git a/src/Umbraco.Infrastructure/PropertyEditors/RichTextPropertyEditor.cs b/src/Umbraco.Infrastructure/PropertyEditors/RichTextPropertyEditor.cs
index 83453ab29b83..a30489ae0caf 100644
--- a/src/Umbraco.Infrastructure/PropertyEditors/RichTextPropertyEditor.cs
+++ b/src/Umbraco.Infrastructure/PropertyEditors/RichTextPropertyEditor.cs
@@ -213,6 +213,10 @@ internal sealed class RichTextPropertyValueEditor : BlockValuePropertyValueEdito
         /// <param name="blockEditorVarianceHandler">Handles variance logic for block editors.</param>
         /// <param name="languageService">Provides language and localization services.</param>
         /// <param name="ioHelper">Helper for IO operations.</param>
+        /// <param name="mediaService">Service for media operations.</param>
+        /// <param name="mediaTypeService">Service for media type operations.</param>
+        /// <param name="localizedTextService">Service for localized text lookups.</param>
+        /// <param name="appCaches">Application caches for request-level caching.</param>
         public RichTextPropertyValueEditor(
             DataEditorAttribute attribute,
             PropertyEditorCollection propertyEditors,
@@ -232,7 +236,11 @@ public RichTextPropertyValueEditor(
             IRichTextRegexValidator richTextRegexValidator,
             BlockEditorVarianceHandler blockEditorVarianceHandler,
             ILanguageService languageService,
-            IIOHelper ioHelper)
+            IIOHelper ioHelper,
+            IMediaService mediaService,
+            IMediaTypeService mediaTypeService,
+            ILocalizedTextService localizedTextService,
+            AppCaches appCaches)
             : base(propertyEditors, dataTypeReadCache, shortStringHelper, jsonSerializer, dataValueReferenceFactoryCollection, blockEditorVarianceHandler, languageService, ioHelper, attribute)
         {
             _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
@@ -248,6 +256,7 @@ public RichTextPropertyValueEditor(
 
             BlockEditorValues = new(new RichTextEditorBlockDataConverter(_jsonSerializer), elementTypeCache, logger);
             Validators.Add(new RichTextEditorBlockValidator(propertyValidationService, BlockEditorValues, elementTypeCache, jsonSerializer, logger));
+            Validators.Add(new RichTextAllowedMediaTypeValidator(imageSourceParser, mediaService, localizedTextService, jsonSerializer, logger, new AllowedMediaTypeHelper(mediaTypeService, appCaches)));
         }
 
         /// <summary>
diff --git a/src/Umbraco.Infrastructure/PropertyEditors/ValueConverters/BlockGridPropertyValueCreator.cs b/src/Umbraco.Infrastructure/PropertyEditors/ValueConverters/BlockGridPropertyValueCreator.cs
index 133e7df8d172..c422bc6b0567 100644
--- a/src/Umbraco.Infrastructure/PropertyEditors/ValueConverters/BlockGridPropertyValueCreator.cs
+++ b/src/Umbraco.Infrastructure/PropertyEditors/ValueConverters/BlockGridPropertyValueCreator.cs
@@ -48,11 +48,14 @@ public BlockGridModel CreateBlockModel(IPublishedElement owner, PropertyCacheLev
 
         BlockGridItem? EnrichBlockItem(BlockGridItem blockItem, BlockGridLayoutItem layoutItem, BlockGridConfiguration.BlockGridBlockConfiguration blockConfig, CreateBlockItemModelFromLayout createBlockItem)
         {
+            const int DefaultRowSpan = 1;
+            const int DefaultColumnSpan = 12;
+
             // enrich block item with additional configs + setup areas
             var blockConfigAreaMap = blockConfig.Areas.ToDictionary(area => area.Key);
 
-            blockItem.RowSpan = layoutItem.RowSpan!.Value;
-            blockItem.ColumnSpan = layoutItem.ColumnSpan!.Value;
+            blockItem.RowSpan = layoutItem.RowSpan ?? DefaultRowSpan;
+            blockItem.ColumnSpan = layoutItem.ColumnSpan ?? gridColumns ?? DefaultColumnSpan;
             blockItem.AreaGridColumns = blockConfig.AreaGridColumns;
             blockItem.GridColumns = gridColumns;
             blockItem.Areas = layoutItem.Areas.Select(area =>
@@ -63,7 +66,7 @@ public BlockGridModel CreateBlockModel(IPublishedElement owner, PropertyCacheLev
                 }
 
                 var items = area.Items.Select(item => createBlockItem(item)).WhereNotNull().ToList();
-                return new BlockGridArea(items, areaConfig.Alias!, areaConfig.RowSpan!.Value, areaConfig.ColumnSpan!.Value);
+                return new BlockGridArea(items, areaConfig.Alias!, areaConfig.RowSpan ?? DefaultRowSpan, areaConfig.ColumnSpan ?? blockConfig.AreaGridColumns ?? gridColumns ?? DefaultColumnSpan);
             }).WhereNotNull().ToArray();
 
             return blockItem;
diff --git a/src/Umbraco.Infrastructure/Security/MemberRoleStore.cs b/src/Umbraco.Infrastructure/Security/MemberRoleStore.cs
index 10f426e94870..f07a62023a62 100644
--- a/src/Umbraco.Infrastructure/Security/MemberRoleStore.cs
+++ b/src/Umbraco.Infrastructure/Security/MemberRoleStore.cs
@@ -39,14 +39,12 @@ public MemberRoleStore(IMemberGroupService memberGroupService, IdentityErrorDesc
     /// </summary>
     public IdentityErrorDescriber ErrorDescriber { get; set; }
 
-    /// <summary>
-    /// Gets a queryable collection of all member roles, represented as <see cref="UmbracoIdentityRole"/>, retrieved from the member group service.
-    /// </summary>
+    /// <inheritdoc/>
     public IQueryable<UmbracoIdentityRole> Roles =>
-        _memberGroupService.GetAll().Select(MapFromMemberGroup).AsQueryable();
+        _memberGroupService.GetAllAsync().GetAwaiter().GetResult().Select(MapFromMemberGroup).AsQueryable();
 
     /// <inheritdoc />
-    public Task<IdentityResult> CreateAsync(UmbracoIdentityRole role, CancellationToken cancellationToken = default)
+    public async Task<IdentityResult> CreateAsync(UmbracoIdentityRole role, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
         ThrowIfDisposed();
@@ -58,15 +56,15 @@ public Task<IdentityResult> CreateAsync(UmbracoIdentityRole role, CancellationTo
 
         var memberGroup = new MemberGroup { Name = role.Name };
 
-        _memberGroupService.Save(memberGroup);
+        await _memberGroupService.CreateAsync(memberGroup);
 
         role.Id = memberGroup.Id.ToString();
 
-        return Task.FromResult(IdentityResult.Success);
+        return IdentityResult.Success;
     }
 
     /// <inheritdoc />
-    public Task<IdentityResult> UpdateAsync(UmbracoIdentityRole role, CancellationToken cancellationToken = default)
+    public async Task<IdentityResult> UpdateAsync(UmbracoIdentityRole role, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
         ThrowIfDisposed();
@@ -78,7 +76,7 @@ public Task<IdentityResult> UpdateAsync(UmbracoIdentityRole role, CancellationTo
 
         if (!int.TryParse(role.Id, NumberStyles.Integer, CultureInfo.InvariantCulture, out var roleId))
         {
-            return Task.FromResult(IdentityResult.Failed(_intParseError));
+            return IdentityResult.Failed(_intParseError);
         }
 
         IMemberGroup? memberGroup = _memberGroupService.GetById(roleId);
@@ -86,13 +84,13 @@ public Task<IdentityResult> UpdateAsync(UmbracoIdentityRole role, CancellationTo
         {
             if (MapToMemberGroup(role, memberGroup))
             {
-                _memberGroupService.Save(memberGroup);
+                await _memberGroupService.UpdateAsync(memberGroup);
             }
 
-            return Task.FromResult(IdentityResult.Success);
+            return IdentityResult.Success;
         }
 
-        return Task.FromResult(IdentityResult.Failed(_memberGroupNotFoundError));
+        return IdentityResult.Failed(_memberGroupNotFoundError);
     }
 
     /// <inheritdoc />
@@ -184,7 +182,7 @@ public Task SetNormalizedRoleNameAsync(
         => SetRoleNameAsync(role, normalizedName, cancellationToken);
 
     /// <inheritdoc />
-    public Task<UmbracoIdentityRole?> FindByIdAsync(string roleId, CancellationToken cancellationToken = default)
+    public async Task<UmbracoIdentityRole?> FindByIdAsync(string roleId, CancellationToken cancellationToken = default)
     {
         cancellationToken.ThrowIfCancellationRequested();
         ThrowIfDisposed();
@@ -198,20 +196,20 @@ public Task SetNormalizedRoleNameAsync(
 
         // member group can be found by int or Guid, so try both
         if (!int.TryParse(roleId, NumberStyles.Integer, CultureInfo.InvariantCulture, out var id))
+        {
+            if (!Guid.TryParse(roleId, out Guid guid))
             {
-                if (!Guid.TryParse(roleId, out Guid guid))
-                {
-                    throw new ArgumentOutOfRangeException(nameof(roleId), $"{nameof(roleId)} is not a valid Guid");
-                }
+                throw new ArgumentOutOfRangeException(nameof(roleId), $"{nameof(roleId)} is not a valid Guid");
+            }
 
-                memberGroup = _memberGroupService.GetById(guid);
+            memberGroup = await _memberGroupService.GetAsync(guid);
         }
         else
         {
             memberGroup = _memberGroupService.GetById(id);
         }
 
-        return Task.FromResult(memberGroup == null ? null : MapFromMemberGroup(memberGroup));
+        return memberGroup == null ? null : MapFromMemberGroup(memberGroup);
     }
 
     /// <inheritdoc />
diff --git a/src/Umbraco.Infrastructure/Security/UmbracoUserManager.cs b/src/Umbraco.Infrastructure/Security/UmbracoUserManager.cs
index 9cef4dd085dd..7e32d524688d 100644
--- a/src/Umbraco.Infrastructure/Security/UmbracoUserManager.cs
+++ b/src/Umbraco.Infrastructure/Security/UmbracoUserManager.cs
@@ -306,7 +306,7 @@ public async Task<bool> ValidateCredentialsAsync(string username, string passwor
     /// </summary>
     /// <param name="user">The user whose valid two-factor providers are to be retrieved.</param>
     /// <returns>A task representing the asynchronous operation, containing a list of valid two-factor provider names.</returns>
-    public virtual async Task<IList<string>> GetValidTwoFactorProvidersAsync(TUser user)
+    public override async Task<IList<string>> GetValidTwoFactorProvidersAsync(TUser user)
     {
         IList<string>? results = await base.GetValidTwoFactorProvidersAsync(user);
 
diff --git a/src/Umbraco.Infrastructure/Telemetry/Providers/DomainTelemetryProvider.cs b/src/Umbraco.Infrastructure/Telemetry/Providers/DomainTelemetryProvider.cs
index 3e51169d38cc..ad043b657fe3 100644
--- a/src/Umbraco.Infrastructure/Telemetry/Providers/DomainTelemetryProvider.cs
+++ b/src/Umbraco.Infrastructure/Telemetry/Providers/DomainTelemetryProvider.cs
@@ -24,7 +24,7 @@ public class DomainTelemetryProvider : IDetailedTelemetryProvider
     /// <returns>An enumerable of <see cref="Umbraco.Cms.Infrastructure.Telemetry.UsageInformation"/> containing domain usage data.</returns>
     public IEnumerable<UsageInformation> GetInformation()
     {
-        var domains = _domainService.GetAll(true).Count();
+        var domains = _domainService.GetAllAsync(true).GetAwaiter().GetResult().Count();
         yield return new UsageInformation(Constants.Telemetry.DomainCount, domains);
     }
 }
diff --git a/src/Umbraco.PublishedCache.HybridCache/NotificationHandlers/CacheRefreshingNotificationHandler.cs b/src/Umbraco.PublishedCache.HybridCache/NotificationHandlers/CacheRefreshingNotificationHandler.cs
index 6a0fd5483a5b..cae642652609 100644
--- a/src/Umbraco.PublishedCache.HybridCache/NotificationHandlers/CacheRefreshingNotificationHandler.cs
+++ b/src/Umbraco.PublishedCache.HybridCache/NotificationHandlers/CacheRefreshingNotificationHandler.cs
@@ -67,11 +67,13 @@ public Task HandleAsync(ContentTypeRefreshedNotification notification, Cancellat
         var structuralChangeIds = notification.Changes
             .Where(x => x.ChangeTypes.IsStructuralChange())
             .Select(x => x.Item.Id)
+            .Distinct()
             .ToArray();
 
         var nonStructuralChangeIds = notification.Changes
             .Where(x => x.ChangeTypes.IsNonStructuralChange())
             .Select(x => x.Item.Id)
+            .Distinct()
             .ToArray();
 
         // Clear content type cache for all changes - content type definitions need refreshing regardless
diff --git a/src/Umbraco.PublishedCache.HybridCache/PublishedProperty.cs b/src/Umbraco.PublishedCache.HybridCache/PublishedProperty.cs
index 93b9df0686c5..c107c4c758ed 100644
--- a/src/Umbraco.PublishedCache.HybridCache/PublishedProperty.cs
+++ b/src/Umbraco.PublishedCache.HybridCache/PublishedProperty.cs
@@ -97,7 +97,7 @@ private static string PropertyCacheValues(Guid contentUid, string typeAlias, boo
     // determines whether a property has value
     public override bool HasValue(string? culture = null, string? segment = null)
     {
-        _variationContextAccessor.ContextualizeVariation(_variations, _element.Id, ref culture, ref segment);
+        _variationContextAccessor.ContextualizeVariation(_variations, _element.Id, PropertyType.Alias, ref culture, ref segment);
 
         var value = GetSourceValue(culture, segment);
         var isValue = PropertyType.IsValue(value, PropertyValueLevel.Source);
@@ -121,7 +121,7 @@ public override bool HasValue(string? culture = null, string? segment = null)
 
     public override object? GetSourceValue(string? culture = null, string? segment = null)
     {
-        _variationContextAccessor.ContextualizeVariation(_sourceVariations, _element.Id, ref culture, ref segment);
+        _variationContextAccessor.ContextualizeVariation(_sourceVariations, _element.Id, PropertyType.Alias, ref culture, ref segment);
 
         // source values are tightly bound to the property/schema culture and segment configurations, so we need to
         // sanitize the contextualized culture/segment states before using them to access the source values.
@@ -164,7 +164,7 @@ public override bool HasValue(string? culture = null, string? segment = null)
 
     public override object? GetValue(string? culture = null, string? segment = null)
     {
-        _variationContextAccessor.ContextualizeVariation(_variations, _element.Id, ref culture, ref segment);
+        _variationContextAccessor.ContextualizeVariation(_variations, _element.Id, PropertyType.Alias, ref culture, ref segment);
 
         object? value;
         CacheValue cacheValues = GetCacheValues(PropertyType.CacheLevel).For(culture, segment);
@@ -227,7 +227,7 @@ private CacheValues GetCacheValues(IAppCache? cache)
 
     public override object? GetDeliveryApiValue(bool expanding, string? culture = null, string? segment = null)
     {
-        _variationContextAccessor.ContextualizeVariation(_variations, _element.Id, ref culture, ref segment);
+        _variationContextAccessor.ContextualizeVariation(_variations, _element.Id, PropertyType.Alias, ref culture, ref segment);
 
         object? value;
         CacheValue cacheValues = GetCacheValues(expanding ? PropertyType.DeliveryApiCacheLevelForExpansion : PropertyType.DeliveryApiCacheLevel).For(culture, segment);
diff --git a/src/Umbraco.PublishedCache.HybridCache/Services/DocumentCacheService.cs b/src/Umbraco.PublishedCache.HybridCache/Services/DocumentCacheService.cs
index c1be40cf247e..3601706ebae2 100644
--- a/src/Umbraco.PublishedCache.HybridCache/Services/DocumentCacheService.cs
+++ b/src/Umbraco.PublishedCache.HybridCache/Services/DocumentCacheService.cs
@@ -148,8 +148,9 @@ await _hybridCache.SetAsync(
             // If we can resolve the content cache node, we still need to check if the ancestor path is published.
             // This does cost some performance, but it's necessary to ensure that the content is actually published.
             // When unpublishing a node, a payload with RefreshBranch is published, so we don't have to worry about this.
-            // Similarly, when a branch is published, next time the content is requested, the parent will be published,
-            // this works because we don't cache null values.
+            // Similarly, when a branch is published, next time the content is requested, the parent will be published.
+            // Null values are cached here are tagged and cleared by ClearMemoryCacheAsync, so the next request after a
+            // cache clear will re-query the database.
             if (preview is false && contentCacheNode is not null && _publishStatusQueryService.HasPublishedAncestorPath(contentCacheNode.Key) is false)
             {
                 // Careful not to early return here. We need to complete the scope even if returning null.
@@ -333,10 +334,25 @@ public async Task RefreshContentAsync(IContent content)
 
     private static string GetCacheKey(Guid key, bool preview) => preview ? $"{key}+draft" : $"{key}";
 
-    // Generates the cache tags for a given CacheNode
-    // We use the tags to be able to clear all cache entries that are related to a given content item.
-    // Tags for now are only content/media, but can be expanded with draft/published later.
-    private static HashSet<string> GenerateTags(ContentCacheNode? cacheNode) => cacheNode is null ? [] : [Constants.Cache.Tags.Content, ContentTypeIdTag(cacheNode.ContentTypeId)];
+    /// <summary>
+    /// Generates the cache tags for a given <see cref="ContentCacheNode"/>.
+    /// </summary>
+    /// <param name="cacheNode">The cache node to generate tags for, or <c>null</c> for a negative-cache entry.</param>
+    /// <returns>
+    /// A set of tags that always includes <see cref="Constants.Cache.Tags.Content"/>.
+    /// When <paramref name="cacheNode"/> is non-null, the content type ID tag is also included.
+    /// </returns>
+    /// <remarks>
+    /// Tags are used to clear all cache entries related to a given content item or type.
+    /// The <see cref="Constants.Cache.Tags.Content"/> tag is always included — even for null entries — so
+    /// that <see cref="ClearMemoryCacheAsync"/> (which clears by this tag) can evict negative-cache entries.
+    /// Without this, null entries survive tag-based cache clears and become permanently stale.
+    /// Tags currently cover content/media distinctions but can be expanded with draft/published later.
+    /// </remarks>
+    private static HashSet<string> GenerateTags(ContentCacheNode? cacheNode) =>
+        cacheNode is null
+            ? [Constants.Cache.Tags.Content]
+            : [Constants.Cache.Tags.Content, ContentTypeIdTag(cacheNode.ContentTypeId)];
 
     public async Task DeleteItemAsync(IContentBase content)
     {
diff --git a/src/Umbraco.PublishedCache.HybridCache/Services/DomainCacheService.cs b/src/Umbraco.PublishedCache.HybridCache/Services/DomainCacheService.cs
index c957f1723143..e778dd275535 100644
--- a/src/Umbraco.PublishedCache.HybridCache/Services/DomainCacheService.cs
+++ b/src/Umbraco.PublishedCache.HybridCache/Services/DomainCacheService.cs
@@ -85,7 +85,8 @@ public void Refresh(DomainCacheRefresher.JsonPayload[] payloads)
                     _domains.Remove(payload.Id, out _);
                     break;
                 case DomainChangeTypes.Refresh:
-                    IDomain? domain = _domainService.GetById(payload.Id);
+                    // TODO: Remove GetByIdAsync(int) when EFCore migration is completed.
+                    IDomain? domain = _domainService.GetByIdAsync(payload.Id).GetAwaiter().GetResult();
                     if (domain == null)
                     {
                         continue;
@@ -119,7 +120,7 @@ private void LoadDomains()
         using (ICoreScope scope = _coreScopeProvider.CreateCoreScope())
         {
             scope.ReadLock(Constants.Locks.Domains);
-            IEnumerable<IDomain> domains = _domainService.GetAll(true);
+            IEnumerable<IDomain> domains = _domainService.GetAllAsync(true).GetAwaiter().GetResult();
             foreach (Domain domain in domains
                          .Where(x => x.RootContentId.HasValue && x.LanguageIsoCode.IsNullOrWhiteSpace() == false)
                          .Select(x => new Domain(x.Id, x.DomainName, x.RootContentId!.Value, x.LanguageIsoCode!, x.IsWildcard, x.SortOrder)))
diff --git a/src/Umbraco.Web.Common/AspNetCore/ApplicationUrlConfigurationNotificationHandler.cs b/src/Umbraco.Web.Common/AspNetCore/ApplicationUrlConfigurationNotificationHandler.cs
new file mode 100644
index 000000000000..5ba8e86d8e51
--- /dev/null
+++ b/src/Umbraco.Web.Common/AspNetCore/ApplicationUrlConfigurationNotificationHandler.cs
@@ -0,0 +1,62 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.Notifications;
+
+namespace Umbraco.Cms.Web.Common.AspNetCore;
+
+/// <summary>
+///     Logs the application URL configuration status at startup, providing guidance
+///     when the URL is not configured and auto-detection is disabled.
+/// </summary>
+internal sealed class ApplicationUrlConfigurationNotificationHandler
+    : INotificationHandler<UmbracoApplicationStartedNotification>
+{
+    private readonly ILogger<ApplicationUrlConfigurationNotificationHandler> _logger;
+    private readonly IOptionsMonitor<WebRoutingSettings> _webRoutingSettings;
+
+    /// <summary>
+    ///     Initializes a new instance of the <see cref="ApplicationUrlConfigurationNotificationHandler" /> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="webRoutingSettings">The web routing settings monitor.</param>
+    public ApplicationUrlConfigurationNotificationHandler(
+        ILogger<ApplicationUrlConfigurationNotificationHandler> logger,
+        IOptionsMonitor<WebRoutingSettings> webRoutingSettings)
+    {
+        _logger = logger;
+        _webRoutingSettings = webRoutingSettings;
+    }
+
+    /// <inheritdoc/>
+    public void Handle(UmbracoApplicationStartedNotification notification)
+    {
+        WebRoutingSettings settings = _webRoutingSettings.CurrentValue;
+
+        if (settings.UmbracoApplicationUrl is not null)
+        {
+            _logger.LogInformation(
+                "Application URL configured as {ApplicationMainUrl}.",
+                settings.UmbracoApplicationUrl);
+            return;
+        }
+
+        if (settings.ApplicationUrlDetection == ApplicationUrlDetection.None)
+        {
+            _logger.LogWarning(
+                "Application URL auto-detection is disabled and no explicit URL is configured. "
+                + "Email links (invitations, password resets) will not be available. "
+                + "Set Umbraco:CMS:WebRouting:UmbracoApplicationUrl in configuration, "
+                + "or change Umbraco:CMS:WebRouting:ApplicationUrlDetection to 'FirstRequest' or 'EveryRequest'.");
+            return;
+        }
+
+        _logger.LogInformation(
+            "Application URL auto-detection is enabled ({DetectionMode}). ",
+            settings.ApplicationUrlDetection);
+    }
+}
diff --git a/src/Umbraco.Web.Common/AspNetCore/AspNetCoreHostingEnvironment.cs b/src/Umbraco.Web.Common/AspNetCore/AspNetCoreHostingEnvironment.cs
index 9a57147bcc05..4c0600be41d3 100644
--- a/src/Umbraco.Web.Common/AspNetCore/AspNetCoreHostingEnvironment.cs
+++ b/src/Umbraco.Web.Common/AspNetCore/AspNetCoreHostingEnvironment.cs
@@ -1,6 +1,5 @@
 using Microsoft.AspNetCore.DataProtection.Infrastructure;
 using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Options;
 using Umbraco.Cms.Core.Collections;
 using Umbraco.Cms.Core.Configuration;
@@ -12,6 +11,10 @@
 
 namespace Umbraco.Cms.Web.Common.AspNetCore;
 
+/// <summary>
+/// ASP.NET Core implementation of <see cref="IHostingEnvironment" /> that provides
+/// hosting information such as the application URL, physical paths, site name, and debug mode.
+/// </summary>
 public class AspNetCoreHostingEnvironment : IHostingEnvironment
 {
     private readonly IApplicationDiscriminator? _applicationDiscriminator;
@@ -22,9 +25,14 @@ public class AspNetCoreHostingEnvironment : IHostingEnvironment
 
     private readonly UrlMode _urlProviderMode;
 
-    private string? _applicationId;
-    private string? _localTempPath;
-
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AspNetCoreHostingEnvironment" /> class
+    /// with an <see cref="IApplicationDiscriminator" /> for unique application identification.
+    /// </summary>
+    /// <param name="hostingSettings">The hosting settings monitor.</param>
+    /// <param name="webRoutingSettings">The web routing settings monitor.</param>
+    /// <param name="webHostEnvironment">The ASP.NET Core web host environment.</param>
+    /// <param name="applicationDiscriminator">The application discriminator used for generating a unique application identifier.</param>
     public AspNetCoreHostingEnvironment(
         IOptionsMonitor<HostingSettings> hostingSettings,
         IOptionsMonitor<WebRoutingSettings> webRoutingSettings,
@@ -33,6 +41,12 @@ public AspNetCoreHostingEnvironment(
         : this(hostingSettings, webRoutingSettings, webHostEnvironment) =>
         _applicationDiscriminator = applicationDiscriminator;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AspNetCoreHostingEnvironment" /> class.
+    /// </summary>
+    /// <param name="hostingSettings">The hosting settings monitor.</param>
+    /// <param name="webRoutingSettings">The web routing settings monitor.</param>
+    /// <param name="webHostEnvironment">The ASP.NET Core web host environment.</param>
     public AspNetCoreHostingEnvironment(
         IOptionsMonitor<HostingSettings> hostingSettings,
         IOptionsMonitor<WebRoutingSettings> webRoutingSettings,
@@ -64,8 +78,14 @@ public AspNetCoreHostingEnvironment(
     /// <inheritdoc />
     public bool IsHosted { get; } = true;
 
+    private Uri? _applicationMainUrl;
+
     /// <inheritdoc />
-    public Uri ApplicationMainUrl { get; private set; } = null!;
+    public Uri ApplicationMainUrl
+    {
+        get => _applicationMainUrl!;
+        private set => _applicationMainUrl = value;
+    }
 
     /// <inheritdoc />
     public string? SiteName { get; private set; }
@@ -75,35 +95,35 @@ public string ApplicationId
     {
         get
         {
-            if (_applicationId != null)
+            if (field != null)
             {
-                return _applicationId;
+                return field;
             }
 
-            _applicationId = _applicationDiscriminator?.GetApplicationId() ??
-                             _webHostEnvironment.GetTemporaryApplicationId();
+            field = _applicationDiscriminator?.GetApplicationId() ?? _webHostEnvironment.GetTemporaryApplicationId();
 
-            return _applicationId;
+            return field;
         }
     }
 
     /// <inheritdoc />
     public string ApplicationPhysicalPath { get; }
 
-    // TODO how to find this, This is a server thing, not application thing.
+    /// <inheritdoc/>
     public string ApplicationVirtualPath =>
         _hostingSettings.CurrentValue.ApplicationVirtualPath?.EnsureStartsWith('/') ?? "/";
 
     /// <inheritdoc />
     public bool IsDebugMode { get; private set; }
 
+    /// <inheritdoc/>
     public string LocalTempPath
     {
         get
         {
-            if (_localTempPath != null)
+            if (field != null)
             {
-                return _localTempPath;
+                return field;
             }
 
             switch (_hostingSettings.CurrentValue.LocalTempStorageLocation)
@@ -123,11 +143,11 @@ public string LocalTempPath
                     var hash = hashString.GenerateHash();
                     var siteTemp = Path.Combine(Path.GetTempPath(), "UmbracoData", hash);
 
-                    return _localTempPath = siteTemp;
+                    return field = siteTemp;
 
                 default:
 
-                    return _localTempPath = MapPathContentRoot(Core.Constants.SystemDirectories.TempData);
+                    return field = MapPathContentRoot(Core.Constants.SystemDirectories.TempData);
             }
         }
     }
@@ -163,32 +183,42 @@ public string ToAbsolute(string virtualPath)
         return fullPath;
     }
 
+    /// <inheritdoc/>
     public void EnsureApplicationMainUrl(Uri? currentApplicationUrl)
     {
-        // TODO: This causes problems with site swap on azure because azure pre-warms a site by calling into `localhost` and when it does that
-        // it changes the URL to `localhost:80` which actually doesn't work for pinging itself, it only works internally in Azure. The ironic part
-        // about this is that this is here specifically for the slot swap scenario https://issues.umbraco.org/issue/U4-10626
-
-        // see U4-10626 - in some cases we want to reset the application url
-        // (this is a simplified version of what was in 7.x)
-        // note: should this be optional? is it expensive?
         if (currentApplicationUrl is null)
         {
             return;
         }
 
+        // Explicit configuration always takes precedence.
         if (_webRoutingSettings.CurrentValue.UmbracoApplicationUrl is not null)
         {
             return;
         }
 
-        var change = !_applicationUrls.Contains(currentApplicationUrl);
-        if (change)
+        switch (_webRoutingSettings.CurrentValue.ApplicationUrlDetection)
         {
-            if (_applicationUrls.TryAdd(currentApplicationUrl))
-            {
-                ApplicationMainUrl = currentApplicationUrl;
-            }
+            case ApplicationUrlDetection.None:
+                return;
+
+            case ApplicationUrlDetection.FirstRequest:
+                // Atomic: only the first thread to arrive sets the URL.
+                // Subsequent calls (even concurrent ones with different hosts) are no-ops.
+                Interlocked.CompareExchange(ref _applicationMainUrl, currentApplicationUrl, null);
+                break;
+
+            case ApplicationUrlDetection.EveryRequest:
+                var change = _applicationUrls.Contains(currentApplicationUrl) is false;
+                if (change)
+                {
+                    if (_applicationUrls.TryAdd(currentApplicationUrl))
+                    {
+                        ApplicationMainUrl = currentApplicationUrl;
+                    }
+                }
+
+                break;
         }
     }
 
diff --git a/src/Umbraco.Web.Common/DependencyInjection/UmbracoBuilder.MembersIdentity.cs b/src/Umbraco.Web.Common/DependencyInjection/UmbracoBuilder.MembersIdentity.cs
index 0b240bf42525..8508c79ff0db 100644
--- a/src/Umbraco.Web.Common/DependencyInjection/UmbracoBuilder.MembersIdentity.cs
+++ b/src/Umbraco.Web.Common/DependencyInjection/UmbracoBuilder.MembersIdentity.cs
@@ -63,13 +63,6 @@ public static IUmbracoBuilder AddMembersIdentity(this IUmbracoBuilder builder)
         services.AddScoped(x => (IMemberUserStore)x.GetRequiredService<IUserStore<MemberIdentityUser>>());
         services.AddScoped<IPasswordHasher<MemberIdentityUser>, MemberPasswordHasher>();
 
-        // TODO (V18): Remove this registration. The base SecurityStampValidatorOptions it configures is not consumed by
-        // any validator — both BackOfficeSecurityStampValidator and MemberSecurityStampValidator use their own derived
-        // options types, each configured by their own IConfigureOptions (which call ConfigureSecurityStampOptions.ConfigureOptions
-        // directly).
-        // Kept for the current major in case external consumers depend on IOptions<SecurityStampValidatorOptions>.
-        services.ConfigureOptions<ConfigureSecurityStampOptions>();
-
         services.ConfigureOptions<ConfigureMemberSecurityStampValidatorOptions>();
         services.ConfigureOptions<ConfigureMemberCookieOptions>();
         services.AddScoped<MemberSecurityStampValidator>();
diff --git a/src/Umbraco.Web.Common/DependencyInjection/UmbracoBuilderExtensions.cs b/src/Umbraco.Web.Common/DependencyInjection/UmbracoBuilderExtensions.cs
index d619d8011577..8f6c757a7fc0 100644
--- a/src/Umbraco.Web.Common/DependencyInjection/UmbracoBuilderExtensions.cs
+++ b/src/Umbraco.Web.Common/DependencyInjection/UmbracoBuilderExtensions.cs
@@ -296,6 +296,7 @@ public static IUmbracoBuilder AddWebComponents(this IUmbracoBuilder builder)
         // AspNetCore specific services
         builder.Services.AddUnique<IRequestAccessor, AspNetCoreRequestAccessor>();
         builder.AddNotificationHandler<UmbracoRequestBeginNotification, ApplicationUrlRequestBeginNotificationHandler>();
+        builder.AddNotificationHandler<UmbracoApplicationStartedNotification, ApplicationUrlConfigurationNotificationHandler>();
 
         // Password hasher
         builder.Services.AddUnique<IPasswordHasher, AspNetCorePasswordHasher>();
diff --git a/src/Umbraco.Web.Common/Security/ConfigureMemberIdentityOptions.cs b/src/Umbraco.Web.Common/Security/ConfigureMemberIdentityOptions.cs
index 1c9b88b6cfdc..7368a464a64b 100644
--- a/src/Umbraco.Web.Common/Security/ConfigureMemberIdentityOptions.cs
+++ b/src/Umbraco.Web.Common/Security/ConfigureMemberIdentityOptions.cs
@@ -7,17 +7,26 @@ namespace Umbraco.Cms.Web.Common.Security;
 
 public sealed class ConfigureMemberIdentityOptions : IConfigureOptions<IdentityOptions>
 {
-    private readonly MemberPasswordConfigurationSettings _memberPasswordConfiguration;
     private readonly SecuritySettings _securitySettings;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ConfigureMemberIdentityOptions" /> class.
+    /// </summary>
+    /// <param name="securitySettings">The security configuration.</param>
     public ConfigureMemberIdentityOptions(
-        IOptions<MemberPasswordConfigurationSettings> memberPasswordConfiguration,
         IOptions<SecuritySettings> securitySettings)
     {
-        _memberPasswordConfiguration = memberPasswordConfiguration.Value;
         _securitySettings = securitySettings.Value;
     }
 
+    [Obsolete("Use the constructor that only takes IOptions<SecuritySettings> instead. Scheduled for removal in Umbraco 19.")]
+    public ConfigureMemberIdentityOptions(
+        IOptions<MemberPasswordConfigurationSettings> memberPasswordConfiguration,
+        IOptions<SecuritySettings> securitySettings)
+        : this(securitySettings)
+    {
+    }
+
     public void Configure(IdentityOptions options)
     {
         options.SignIn.RequireConfirmedAccount = true; // uses our custom IUserConfirmation
@@ -33,8 +42,8 @@ public void Configure(IdentityOptions options)
 
         options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(_securitySettings.MemberDefaultLockoutTimeInMinutes);
 
-        options.Password.ConfigurePasswordOptions(_memberPasswordConfiguration);
+        options.Password.ConfigurePasswordOptions(_securitySettings.MemberPassword);
 
-        options.Lockout.MaxFailedAccessAttempts = _memberPasswordConfiguration.MaxFailedAccessAttemptsBeforeLockout;
+        options.Lockout.MaxFailedAccessAttempts = _securitySettings.MemberPassword.MaxFailedAccessAttemptsBeforeLockout;
     }
 }
diff --git a/src/Umbraco.Web.Common/Templates/TemplateRenderer.cs b/src/Umbraco.Web.Common/Templates/TemplateRenderer.cs
index f60833a4b788..a7bbcb788080 100644
--- a/src/Umbraco.Web.Common/Templates/TemplateRenderer.cs
+++ b/src/Umbraco.Web.Common/Templates/TemplateRenderer.cs
@@ -30,14 +30,28 @@ internal sealed class TemplateRenderer : ITemplateRenderer
 {
     private readonly IFileService _fileService;
     private readonly IHttpContextAccessor _httpContextAccessor;
-    private readonly ILocalizationService _languageService;
     private readonly IModelMetadataProvider _modelMetadataProvider;
     private readonly IPublishedRouter _publishedRouter;
     private readonly ITempDataDictionaryFactory _tempDataDictionaryFactory;
     private readonly IUmbracoContextAccessor _umbracoContextAccessor;
     private readonly ICompositeViewEngine _viewEngine;
     private WebRoutingSettings _webRoutingSettings;
+    private readonly ILanguageService _languageService;
 
+    /// <summary>
+    /// Initializes a new instance of the <see cref="TemplateRenderer"/> class.
+    /// </summary>
+    /// <param name="umbracoContextAccessor">Provides access to the current Umbraco context.</param>
+    /// <param name="publishedRouter">The published router</param>
+    /// <param name="fileService"></param>
+    /// <param name="textService"></param>
+    /// <param name="webRoutingSettings"></param>
+    /// <param name="httpContextAccessor"></param>
+    /// <param name="viewEngine"></param>
+    /// <param name="modelMetadataProvider"></param>
+    /// <param name="tempDataDictionaryFactory"></param>
+    /// <param name="languageService"></param>
+    /// <exception cref="ArgumentNullException"></exception>
     public TemplateRenderer(
         IUmbracoContextAccessor umbracoContextAccessor,
         IPublishedRouter publishedRouter,
@@ -47,13 +61,13 @@ public TemplateRenderer(
         IHttpContextAccessor httpContextAccessor,
         ICompositeViewEngine viewEngine,
         IModelMetadataProvider modelMetadataProvider,
-        ITempDataDictionaryFactory tempDataDictionaryFactory)
+        ITempDataDictionaryFactory tempDataDictionaryFactory,
+        ILanguageService languageService)
     {
         _umbracoContextAccessor =
             umbracoContextAccessor ?? throw new ArgumentNullException(nameof(umbracoContextAccessor));
         _publishedRouter = publishedRouter ?? throw new ArgumentNullException(nameof(publishedRouter));
         _fileService = fileService ?? throw new ArgumentNullException(nameof(fileService));
-        _languageService = textService ?? throw new ArgumentNullException(nameof(textService));
         _webRoutingSettings = webRoutingSettings.CurrentValue ??
                               throw new ArgumentNullException(nameof(webRoutingSettings));
         _httpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
@@ -62,6 +76,7 @@ public TemplateRenderer(
         _tempDataDictionaryFactory = tempDataDictionaryFactory;
 
         webRoutingSettings.OnChange(x => _webRoutingSettings = x);
+        _languageService = languageService;
     }
 
     public async Task RenderAsync(int pageId, int? altTemplateId, StringWriter writer)
@@ -92,7 +107,7 @@ public async Task RenderAsync(int pageId, int? altTemplateId, StringWriter write
         // set the culture to the same as is currently rendering
         if (umbracoContext.PublishedRequest == null)
         {
-            ILanguage? defaultLanguage = _languageService.GetAllLanguages().FirstOrDefault();
+            ILanguage? defaultLanguage = await _languageService.GetDefaultLanguageAsync();
 
             requestBuilder.SetCulture(defaultLanguage == null
                 ? CultureInfo.CurrentUICulture.Name
diff --git a/src/Umbraco.Web.UI.Client/.claude/skills/core-add-module/SKILL.md b/src/Umbraco.Web.UI.Client/.claude/skills/core-add-module/SKILL.md
new file mode 100644
index 000000000000..3fbea02e8257
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/.claude/skills/core-add-module/SKILL.md
@@ -0,0 +1,140 @@
+---
+name: core-add-module
+description: Add a new module to the core package (src/packages/core/). Use when adding shared UI framework infrastructure that all packages can use — e.g., a new extension system feature, a new utility, a new shared component pattern, a new picker, or a new workspace primitive. Core modules are imported as @umbraco-cms/backoffice/{module-name}. Also use when the user says things like "add a module to core", "create a new core feature", or "add shared infrastructure".
+allowed-tools: Read, Write, Edit, Grep, Glob
+---
+
+# Add Core Module
+
+Add a new module to the core package (`src/packages/core/`).
+
+## Naming conventions
+
+- **Module names** are **singular** (e.g., `picker`, `sorter`, `entity-flag`, `modal`, `section`)
+
+## What you need from the user
+
+1. **Module name** — What to call it in singular form (kebab-case, e.g., `picker`, `sorter`, `entity-flag`)
+2. **Purpose** — What shared infrastructure this provides
+
+## When to add to core vs. create a new package
+
+- **Core module**: Shared UI framework infrastructure used by multiple packages — extension primitives, pickers, validation, repository base classes, workspace utilities.
+- **New package**: Domain-specific CMS features (documents, media, webhook). Use the `create-package` skill instead.
+
+Core modules should not implement CMS-specific features. They provide the building blocks that CMS feature packages use.
+
+## Files to create
+
+```
+src/packages/core/{module-name}/
+├── index.ts                   # Public API exports
+├── manifests.ts               # Extension registrations (if any)
+├── constants.ts               # Module constants
+└── types.ts                   # Module types
+```
+
+## Step 1: Create the module directory and files
+
+### {module-name}/index.ts
+
+The public API. Only export what other packages need:
+
+```typescript
+export * from './constants.js';
+export type * from './types.js';
+```
+
+Use `export type *` for type-only exports.
+
+### {module-name}/manifests.ts
+
+Extension registrations for this module:
+
+```typescript
+export const manifests: Array<UmbExtensionManifest> = [
+	// Extension registrations
+];
+```
+
+If the module has no extensions (pure utility), export an empty array.
+
+### {module-name}/constants.ts
+
+```typescript
+// Aliases, context tokens, entity types
+```
+
+### {module-name}/types.ts
+
+```typescript
+// Type definitions, interfaces, meta types
+```
+
+## Step 2: Wire into core's manifests.ts
+
+Add the module's manifests to `src/packages/core/manifests.ts`:
+
+```typescript
+import { manifests as {moduleName}Manifests } from './{module-name}/manifests.js';
+
+// In the manifests array:
+...{moduleName}Manifests,
+```
+
+The imports are in alphabetical order — insert in the right position.
+
+## Step 3: Add entry point to core's vite.config.ts
+
+Add the module to the `entry` object in `src/packages/core/vite.config.ts`:
+
+```typescript
+'{module-name}/index': './{module-name}/index.ts',
+```
+
+The entries are in alphabetical order — insert in the right position. This tells Vite to build the module as a separate entry point.
+
+## Step 4: Register the subpath export
+
+Add to the `exports` field in the root `package.json` (`src/Umbraco.Web.UI.Client/package.json`):
+
+```json
+"./{module-name}": "./dist-cms/packages/core/{module-name}/index.js"
+```
+
+This enables imports like `@umbraco-cms/backoffice/{module-name}`.
+
+## Step 5: Regenerate TypeScript config
+
+```bash
+npm run generate:tsconfig
+```
+
+This updates `tsconfig.json` paths so the new module resolves correctly in TypeScript.
+
+## How consumers import
+
+After registration, other packages import from the module like:
+
+```typescript
+import { MyThing } from '@umbraco-cms/backoffice/{module-name}';
+import type { MyType } from '@umbraco-cms/backoffice/{module-name}';
+```
+
+## Reference: existing core modules to study
+
+- **Simple utility**: `src/packages/core/culture/` — repository + components, minimal surface
+- **Extension primitive**: `src/packages/core/entity-action/` — kinds, base classes, shared element
+- **Infrastructure**: `src/packages/core/repository/` — base classes for the data access pattern
+
+## Checklist
+
+- [ ] Module directory created under `src/packages/core/`
+- [ ] `index.ts` exports only the public API
+- [ ] `manifests.ts` exports extension registrations (or empty array)
+- [ ] `constants.ts` and `types.ts` created
+- [ ] Module manifests imported in `src/packages/core/manifests.ts` (alphabetical order)
+- [ ] Entry point added to `src/packages/core/vite.config.ts` (alphabetical order)
+- [ ] Subpath export added to root `package.json`
+- [ ] `npm run generate:tsconfig` executed
+- [ ] Compiles: `npm run compile`
diff --git a/src/Umbraco.Web.UI.Client/.claude/skills/general-add-localization/SKILL.md b/src/Umbraco.Web.UI.Client/.claude/skills/general-add-localization/SKILL.md
new file mode 100644
index 000000000000..4bff990c18c1
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/.claude/skills/general-add-localization/SKILL.md
@@ -0,0 +1,101 @@
+---
+name: general-add-localization
+description: Add localization keys and use them in elements or controllers. Use when adding user-facing text that should be translatable — labels, descriptions, error messages, button text, status text, or any string shown in the backoffice UI.
+allowed-tools: Read, Write, Edit, Grep, Glob
+---
+
+# Add Localization
+
+Add translatable text to the Umbraco backoffice.
+
+## What you need from the user
+
+1. **The text to localize** — What the user sees (e.g., "Create item", "Status")
+2. **Which group it belongs to** — Feature area (e.g., `actions`, `general`, `content`, `user`)
+3. **Where it's used** — Element template, controller logic, or standalone component
+
+## Step 1: Add the key to the English dictionary
+
+**File:** `src/assets/lang/en.ts`
+
+This file exports a `UmbLocalizationDictionary` — a nested object where top-level keys are groups and nested keys are the terms.
+
+```typescript
+// src/assets/lang/en.ts
+export default {
+	// ... existing groups
+	myFeature: {
+		myLabel: 'My Label',
+		myDescription: 'A description of the feature',
+		createFor: (name: string) => (name ? `Create item for ${name}` : 'Create'),
+	},
+} satisfies UmbLocalizationDictionary;
+```
+
+### Key naming rules
+
+- **Group**: camelCase feature name (e.g., `actions`, `general`, `content`, `media`, `user`)
+- **Term**: camelCase descriptive name (e.g., `assignDomain`, `auditTrail`, `browse`)
+- **Full key** used in code: `group_termName` (underscore separator)
+- Add to an **existing group** when the text belongs to that feature area
+- Create a **new group** only for new feature areas
+
+### Value types
+
+| Type | Use when | Example |
+|------|----------|---------|
+| `string` | Static text | `myLabel: 'My Label'` |
+| `(args) => string` | Text with dynamic values | `createFor: (name: string) => \`Create ${name}\`` |
+
+## Step 2: Use the localized text
+
+### In element templates — `this.localize.term()`
+
+Available on any class extending `UmbLitElement`. The `localize` property is provided automatically.
+
+```typescript
+import { customElement, html } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+
+@customElement('umb-my-element')
+export class UmbMyElement extends UmbLitElement {
+	override render() {
+		return html`
+			<uui-button label=${this.localize.term('myFeature_myLabel')}></uui-button>
+		`;
+	}
+}
+```
+
+### In templates — `<umb-localize>` element
+
+For inline localized text in HTML templates:
+
+```html
+<umb-localize key="myFeature_myLabel"></umb-localize>
+
+<!-- With fallback text (shown if key is missing) -->
+<umb-localize key="myFeature_myLabel">Fallback text</umb-localize>
+```
+
+### In controllers or non-element classes — `UmbLocalizationController`
+
+```typescript
+import { UmbLocalizationController } from '@umbraco-cms/backoffice/localization-api';
+
+export class UmbMyManager extends UmbControllerBase {
+	readonly #localization = new UmbLocalizationController(this);
+
+	someMethod() {
+		const label = this.#localization.term('myFeature_myLabel');
+	}
+}
+```
+
+## Checklist
+
+- [ ] Key added to `src/assets/lang/en.ts` in the correct group
+- [ ] Key follows `group_termName` convention (camelCase, underscore separator)
+- [ ] Used `this.localize.term()` in elements or `UmbLocalizationController` in non-elements
+- [ ] No hardcoded user-facing strings remain
+- [ ] Compiles: `npm run compile`
diff --git a/src/Umbraco.Web.UI.Client/.claude/skills/general-create-condition/SKILL.md b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-condition/SKILL.md
new file mode 100644
index 000000000000..e1e6bb11d2c2
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-condition/SKILL.md
@@ -0,0 +1,209 @@
+---
+name: general-create-condition
+description: Create a new extension condition that controls when extensions are active. Use when you need to conditionally show or hide extensions based on application state (e.g., current section, user permissions, entity state, workspace context). Conditions are registered as extensions and referenced in manifest condition arrays.
+allowed-tools: Read, Write, Edit, Grep, Glob
+---
+
+# Create Condition
+
+Create a new extension condition that controls when extensions are active.
+
+## What you need from the user
+
+1. **What it checks** — What context or state determines the condition (e.g., current section, user role, entity state)
+2. **Config properties** — What parameters consumers provide (e.g., `match`, `oneOf`)
+3. **Context dependency** — Which context token provides the data to evaluate
+
+## Files to create
+
+Place in a `conditions/` subdirectory of the relevant feature:
+
+```
+my-feature/
+└── conditions/
+    └── my-condition/
+        ├── constants.ts                     # Condition alias constant
+        ├── types.ts                         # Config type + global declaration
+        ├── my-condition.condition.ts         # Condition controller
+        └── manifests.ts                     # Condition manifest
+```
+
+## Step 1: Define the alias constant
+
+```typescript
+// constants.ts
+export const UMB_MY_CONDITION_ALIAS = 'Umb.Condition.MyCondition';
+```
+
+## Step 2: Define the config type
+
+```typescript
+// types.ts
+import type { UMB_MY_CONDITION_ALIAS } from './constants.js';
+import type { UmbConditionConfigBase } from '@umbraco-cms/backoffice/extension-api';
+
+export interface MyConditionConfig extends UmbConditionConfigBase<typeof UMB_MY_CONDITION_ALIAS> {
+	/**
+	 * The value to match against.
+	 * @example "Umb.Section.Content"
+	 */
+	match?: string;
+
+	/**
+	 * One or more values to match against (any match passes).
+	 * @example ["Umb.Section.Content", "Umb.Section.Media"]
+	 */
+	oneOf?: Array<string>;
+}
+
+declare global {
+	interface UmbExtensionConditionConfigMap {
+		UmbMyConditionConfig: MyConditionConfig;
+	}
+}
+```
+
+### Key rules
+
+- Extend `UmbConditionConfigBase<typeof ALIAS_CONSTANT>` — this types the `alias` property
+- The `declare global` block on `UmbExtensionConditionConfigMap` makes the config type-safe when used in extension manifests
+- Use a unique key in the map
+- Add JSDoc with `@example` — these feed into JSON schema generation
+
+### Common config patterns
+
+| Pattern | Use when |
+|---------|----------|
+| `match: string` | Single value match |
+| `oneOf: Array<string>` | Any of multiple values |
+| `allOf: Array<string>` | All values must match |
+| `noneOf: Array<string>` | None of the values match |
+| No config properties | Condition checks a boolean state (e.g., "is trashed", "is admin") |
+
+## Step 3: Implement the condition controller
+
+```typescript
+// my-condition.condition.ts
+import type { MyConditionConfig } from './types.js';
+import { UMB_MY_CONTEXT } from '../../my-context.token.js';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import type { UmbConditionControllerArguments, UmbExtensionCondition } from '@umbraco-cms/backoffice/extension-api';
+import { UmbConditionBase } from '@umbraco-cms/backoffice/extension-registry';
+
+export class UmbMyCondition
+	extends UmbConditionBase<MyConditionConfig>
+	implements UmbExtensionCondition
+{
+	constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<MyConditionConfig>) {
+		super(host, args);
+
+		this.consumeContext(UMB_MY_CONTEXT, (context) => {
+			this.observe(
+				context.someObservable,
+				(value) => {
+					this.permitted = this.#check(value);
+				},
+				'_observeConditionValue',
+			);
+		});
+	}
+
+	#check(value: string | undefined): boolean {
+		if (!value) return false;
+
+		if (this.config.match) {
+			return value === this.config.match;
+		}
+
+		if (this.config.oneOf) {
+			return this.config.oneOf.includes(value);
+		}
+
+		return false;
+	}
+}
+
+export { UmbMyCondition as api };
+```
+
+### Key rules
+
+- Extend `UmbConditionBase<ConfigType>` — provides `permitted` property and `config` access
+- Implement `UmbExtensionCondition`
+- Constructor signature: `(host: UmbControllerHost, args: UmbConditionControllerArguments<ConfigType>)`
+- Set `this.permitted = true/false` — the base class notifies the extension system on change
+- Use `consumeContext()` + `observe()` for reactive conditions that update as state changes
+- Export as `api` (named export) so the class can be imported by the manifest
+- Use an explicit observer alias so re-evaluation replaces the previous subscription
+
+### For simple boolean conditions (no config)
+
+```typescript
+export class UmbIsSomethingCondition
+	extends UmbConditionBase<UmbConditionConfigBase>
+	implements UmbExtensionCondition
+{
+	constructor(host: UmbControllerHost, args: UmbConditionControllerArguments<UmbConditionConfigBase>) {
+		super(host, args);
+
+		this.consumeContext(UMB_SOME_CONTEXT, (context) => {
+			this.observe(context.isSomething, (value) => {
+				this.permitted = value === true;
+			});
+		});
+	}
+}
+```
+
+## Step 4: Register the condition manifest
+
+Conditions must load fast — always import the class directly (no lazy `() => import()`).
+
+```typescript
+// manifests.ts
+import { UMB_MY_CONDITION_ALIAS } from './constants.js';
+import { UmbMyCondition } from './my-condition.condition.js';
+
+export const manifests: Array<UmbExtensionManifest> = [
+	{
+		type: 'condition',
+		name: 'My Condition',
+		alias: UMB_MY_CONDITION_ALIAS,
+		api: UmbMyCondition,
+	},
+];
+```
+
+Add to the parent feature's `manifests.ts` so it bubbles up to the bundle.
+
+## How consumers use the condition
+
+In any extension manifest that supports conditions:
+
+```typescript
+{
+	type: 'workspaceAction',
+	alias: 'My.WorkspaceAction',
+	name: 'My Action',
+	conditions: [
+		{
+			alias: 'Umb.Condition.MyCondition',
+			match: 'some-value',
+		},
+	],
+}
+```
+
+All conditions in the array must be `permitted` for the extension to be active. They are AND-ed together.
+
+## Checklist
+
+- [ ] Alias constant exported from `constants.ts`
+- [ ] Config type extends `UmbConditionConfigBase<typeof ALIAS>` with the alias constant
+- [ ] Config type declared on global `UmbExtensionConditionConfigMap`
+- [ ] Condition class extends `UmbConditionBase<ConfigType>` and implements `UmbExtensionCondition`
+- [ ] Constructor calls `super(host, args)` and sets up context observation
+- [ ] `this.permitted` is set reactively (via `observe()`) — not just once in the constructor
+- [ ] Condition manifest registered with `type: 'condition'`
+- [ ] Manifests bubbled up to the package-level `manifests.ts`
+- [ ] Compiles: `npm run compile`
diff --git a/src/Umbraco.Web.UI.Client/.claude/skills/general-create-extension-type/SKILL.md b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-extension-type/SKILL.md
new file mode 100644
index 000000000000..f3b6e8c3d153
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-extension-type/SKILL.md
@@ -0,0 +1,141 @@
+---
+name: general-create-extension-type
+description: Create a new extension type for the Umbraco backoffice extension registry. Use when adding a new type of extension that can be registered via manifests (e.g., a new dashboard type, a new sidebar app type, a new toolbar extension type). Any package can define extension types.
+allowed-tools: Read, Write, Edit, Grep, Glob
+---
+
+# Create Extension Type
+
+Create a new extension type for the Umbraco backoffice extension registry.
+
+## What you need from the user
+
+1. **Type name** — The `type` string used in manifests (e.g., `'dashboard'`, `'searchProvider'`)
+2. **Purpose** — What this extension type does (determines which base interface to extend)
+3. **Meta shape** — What configuration the extension needs from consumers
+4. **Whether it needs conditions** — Should extensions of this type support conditional loading?
+5. **Whether it has an element, API, or both** — Does it render UI, provide logic, or both?
+
+## Files to create
+
+All files go in the relevant feature directory (e.g., `src/packages/my-package/my-feature/`).
+
+```
+my-feature/
+├── my-feature.extension.ts     # Type definition + global declaration
+├── my-feature-element.interface.ts  # Element interface (if element-based)
+└── types.ts                    # Meta interface (if needed)
+```
+
+## Step 1: Choose the base manifest interface
+
+| Your extension... | Extend from | Import |
+|---|---|---|
+| Renders a custom element | `ManifestElement<T>` | `@umbraco-cms/backoffice/extension-api` |
+| Provides an API class (no UI) | `ManifestApi<T>` | `@umbraco-cms/backoffice/extension-api` |
+| Has both element and API | `ManifestElementAndApi<E, A>` | `@umbraco-cms/backoffice/extension-api` |
+| Needs conditional loading | Also extend `ManifestWithDynamicConditions<UmbExtensionConditionConfig>` | `@umbraco-cms/backoffice/extension-api` |
+
+## Step 2: Define the manifest interface
+
+```typescript
+// my-feature.extension.ts
+import type { ManifestElement, ManifestWithDynamicConditions } from '@umbraco-cms/backoffice/extension-api';
+
+export interface MetaMyFeature {
+	label?: string;
+	// ... properties consumers configure via meta
+}
+
+export interface ManifestMyFeature
+	extends ManifestElement<UmbMyFeatureElement>,
+		ManifestWithDynamicConditions<UmbExtensionConditionConfig> {
+	type: 'myFeature';
+	meta: MetaMyFeature;
+}
+
+declare global {
+	interface UmbExtensionManifestMap {
+		umbMyFeature: ManifestMyFeature;
+	}
+}
+```
+
+### Key rules
+
+- The `type` property must be a **string literal type** (not `string`)
+- The key in `UmbExtensionManifestMap` must be unique across the entire codebase
+- The `declare global` block is what makes the registry type-aware — without it, the type won't be recognized
+
+## Step 3: Define the element/API interface (if needed)
+
+```typescript
+// my-feature-element.interface.ts
+import type { UmbElement } from '@umbraco-cms/backoffice/element-api';
+
+export interface UmbMyFeatureElement extends UmbElement {
+	// Properties/methods that implementations must provide
+}
+```
+
+## Step 4: If the type supports kinds
+
+Add a union type for the base manifest plus kind-specific variants:
+
+```typescript
+export interface ManifestMyFeatureButtonKind extends ManifestMyFeature {
+	type: 'myFeature';
+	kind: 'button';
+	meta: MetaMyFeatureButtonKind;
+}
+
+export interface MetaMyFeatureButtonKind extends MetaMyFeature {
+	icon: string;
+}
+
+// Union all variants in the global declaration
+declare global {
+	interface UmbExtensionManifestMap {
+		umbMyFeature: ManifestMyFeature | ManifestMyFeatureButtonKind;
+	}
+}
+```
+
+## Step 5: Export from the package barrel
+
+Add the type export to the package's `index.ts`:
+
+```typescript
+export type * from './my-feature/my-feature.extension.js';
+```
+
+Use `export type *` since these are type-only exports.
+
+## Step 6: Register manifests that use this type
+
+Verify the type works by creating a test manifest:
+
+```typescript
+const manifest: UmbExtensionManifest = {
+	type: 'myFeature',
+	alias: 'Umb.MyFeature.Test',
+	name: 'Test My Feature',
+	element: () => import('./my-feature-test.element.js'),
+	meta: {
+		label: 'Test',
+	},
+};
+```
+
+TypeScript should provide autocomplete for `type` and validate `meta` against `MetaMyFeature`.
+
+## Checklist
+
+- [ ] Manifest interface extends the correct base (`ManifestElement`, `ManifestApi`, or `ManifestElementAndApi`)
+- [ ] `type` property is a string literal, not `string`
+- [ ] `declare global` block adds to `UmbExtensionManifestMap` with a unique key
+- [ ] Meta interface is defined separately and exported
+- [ ] Element/API interface is defined if the type renders UI or provides logic
+- [ ] If kinds are supported: kind-specific interfaces extend the base with literal `kind` property
+- [ ] Type is exported from the package's `index.ts`
+- [ ] Compiles: `npm run compile`
diff --git a/src/Umbraco.Web.UI.Client/.claude/skills/general-create-kind/SKILL.md b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-kind/SKILL.md
new file mode 100644
index 000000000000..1562b480fa19
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-kind/SKILL.md
@@ -0,0 +1,198 @@
+---
+name: general-create-kind
+description: Create a new extension kind — a reusable default implementation for an extension type. Use when multiple extensions of the same type share the same element/API implementation and only differ in configuration. Kinds reduce boilerplate by providing pre-built defaults that extensions customize via meta.
+allowed-tools: Read, Write, Edit, Grep, Glob
+---
+
+# Create Kind
+
+Create a new extension kind — a reusable default implementation for an extension type.
+
+## What you need from the user
+
+1. **Which extension type** — The `type` this kind applies to (e.g., `'entityAction'`, `'section'`)
+2. **Kind name** — The `kind` string (e.g., `'delete'`, `'default'`, `'button'`)
+3. **What it provides** — Default element, API, or both
+4. **Meta defaults** — What meta values the kind pre-fills for consumers
+
+## When to create a kind
+
+Create a kind when **multiple extensions of the same type share the same element/API implementation** and only differ in meta configuration. If the implementation is unique, a kind adds unnecessary indirection.
+
+## Files to create
+
+```
+my-feature/
+├── kinds/
+│   └── my-kind/
+│       ├── my-kind.kind.ts              # Kind manifest definition
+│       ├── my-kind.element.ts           # Default element (if providing UI)
+│       ├── my-kind.api.ts               # Default API class (if providing logic)
+│       └── manifests.ts                 # Exports the kind manifest
+```
+
+## Step 1: Define the kind manifest
+
+```typescript
+// my-kind.kind.ts
+import type { UmbExtensionManifestKind } from '@umbraco-cms/backoffice/extension-registry';
+
+export const UMB_MY_FEATURE_MY_KIND_MANIFEST: UmbExtensionManifestKind = {
+	type: 'kind',
+	alias: 'Umb.Kind.MyFeature.MyKind',
+	matchType: 'myFeature',
+	matchKind: 'myKind',
+	manifest: {
+		type: 'myFeature',
+		kind: 'myKind',
+		element: () => import('./my-kind.element.js'),
+		api: () => import('./my-kind.api.js'),
+		weight: 1000,
+		meta: {
+			icon: '',
+			label: '',
+			// ... defaults that consumers override
+		},
+	},
+};
+
+export const manifest = UMB_MY_FEATURE_MY_KIND_MANIFEST;
+```
+
+### Key fields
+
+- **`type`**: Always `'kind'`
+- **`alias`**: Unique identifier. Convention: `Umb.Kind.{ExtensionType}.{KindName}`
+- **`matchType`**: The extension type this kind applies to
+- **`matchKind`**: The kind name that extensions reference
+- **`manifest`**: Partial manifest with defaults — any property here becomes the base for extensions using this kind
+
+## Step 2: Create the default element (if providing UI)
+
+```typescript
+// my-kind.element.ts
+import { customElement, html } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+
+@customElement('umb-my-kind-element')
+export class UmbMyKindElement extends UmbLitElement {
+	// This element is shared by all extensions using this kind.
+	// Use manifest meta for customization — not hardcoded values.
+
+	override render() {
+		return html`<!-- default rendering -->`;
+	}
+}
+
+export { UmbMyKindElement as element };
+```
+
+**Important:** Export as `element` (named export) — the lazy `import()` in the kind manifest resolves this name.
+
+## Step 3: Create the default API (if providing logic)
+
+```typescript
+// my-kind.api.ts
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+
+export class UmbMyKindApi extends UmbControllerBase {
+	// Shared logic for all extensions using this kind.
+	// Access extension-specific config via the manifest meta.
+}
+
+export { UmbMyKindApi as api };
+```
+
+## Step 4: Register the kind in manifests
+
+```typescript
+// manifests.ts
+import { manifest as myKindManifest } from './my-kind.kind.js';
+import type { UmbExtensionManifestKind } from '@umbraco-cms/backoffice/extension-registry';
+
+export const manifests: Array<UmbExtensionManifest | UmbExtensionManifestKind> = [myKindManifest];
+```
+
+Add this to the parent feature's `manifests.ts` so it bubbles up to the bundle.
+
+## Step 5: Add kind-specific type to the extension type (if not already done)
+
+In the extension type definition file, add a variant interface for this kind:
+
+```typescript
+export interface ManifestMyFeatureMyKind extends ManifestMyFeature {
+	type: 'myFeature';
+	kind: 'myKind';
+	meta: MetaMyFeatureMyKind;
+}
+
+export interface MetaMyFeatureMyKind extends MetaMyFeature {
+	icon: string;
+	label: string;
+}
+
+// Update the global declaration to include the kind variant
+declare global {
+	interface UmbExtensionManifestMap {
+		umbMyFeature: ManifestMyFeature | ManifestMyFeatureMyKind;
+	}
+}
+```
+
+## How consumers use the kind
+
+Extensions reference the kind and only specify what differs:
+
+```typescript
+{
+	type: 'myFeature',
+	kind: 'myKind',
+	alias: 'My.Package.MyFeature.Specific',
+	name: 'My Specific Feature',
+	meta: {
+		icon: 'icon-heart',
+		label: 'My Label',
+	},
+}
+```
+
+The registry merges the kind defaults with the extension manifest:
+- Extension properties **override** kind properties
+- `meta` is **shallow-merged** (extension meta extends kind meta, doesn't replace it)
+
+## Extending an existing kind
+
+A kind can build on another kind by spreading its manifest:
+
+```typescript
+import { UMB_MY_FEATURE_DEFAULT_KIND_MANIFEST } from '../default/default.kind.js';
+
+export const manifest: UmbExtensionManifestKind = {
+	type: 'kind',
+	alias: 'Umb.Kind.MyFeature.Special',
+	matchType: 'myFeature',
+	matchKind: 'special',
+	manifest: {
+		...UMB_MY_FEATURE_DEFAULT_KIND_MANIFEST.manifest,
+		type: 'myFeature',
+		kind: 'special',
+		api: () => import('./special.api.js'),
+		meta: {
+			...UMB_MY_FEATURE_DEFAULT_KIND_MANIFEST.manifest.meta,
+			// additional meta defaults
+		},
+	},
+};
+```
+
+## Checklist
+
+- [ ] Kind manifest has `type: 'kind'` with unique `alias`
+- [ ] `matchType` matches the target extension type exactly
+- [ ] `matchKind` matches the `kind` string extensions will use
+- [ ] Default element exported as `element`, default API exported as `api` (named exports for lazy import)
+- [ ] Kind-specific manifest interface added to the extension type's `declare global` block
+- [ ] Kind registered in `manifests.ts` with type `Array<UmbExtensionManifest | UmbExtensionManifestKind>`
+- [ ] Meta defaults use empty strings or sensible fallbacks (not undefined)
+- [ ] Compiles: `npm run compile`
+- [ ] Blast radius considered: changing this kind affects all extensions that use it
diff --git a/src/Umbraco.Web.UI.Client/.claude/skills/general-create-package/SKILL.md b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-package/SKILL.md
new file mode 100644
index 000000000000..c48b86d2d72f
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-package/SKILL.md
@@ -0,0 +1,188 @@
+---
+name: general-create-package
+description: Create a new package in the Umbraco backoffice client with its first module. Use when adding a new domain feature area that needs its own package under src/packages/ — e.g., a new CMS feature like data types, tags, or relations. Packages are self-contained domain modules that can theoretically be uninstalled independently. Also use when the user says things like "scaffold a new package", "add a new feature package", or "create a new domain module".
+allowed-tools: Read, Write, Edit, Grep, Glob
+---
+
+# Create Package
+
+Create a new self-contained package under `src/packages/` with its first module.
+
+## Foundational documentation
+
+Read these docs before creating a package — they define the conventions this skill builds on:
+
+- **[Package Development](../../../docs/package-development.md)** — Package & module structure, folder conventions, manifest bubbling, public API rules
+- **[Entities](../../../docs/entities.md)** — Entity types, entity context, how entityType connects workspaces/trees/actions/routing
+- **[Data Flow](../../../docs/data-flow.md)** — Repository pattern, data sources, stores, worked examples
+
+## Naming conventions
+
+- **Package names** are **plural** (e.g., `data-types`, `languages`, `tags`, `documents`, `relations`)
+- **Module names** are **singular** (e.g., `data-type`, `language`, `tag`, `document`, `relation`)
+
+## What you need from the user
+
+1. **Package name** — The domain name in plural form (e.g., `data-types`, `languages`, `tags`) — kebab-case
+2. **First module name** — The primary module in singular form (e.g., `data-type`, `language`, `tag`)
+
+## When to create a package vs. add to core
+
+- **New package**: Domain-specific CMS features (documents, media, data-type, language). Each package is independent and self-contained.
+- **Add to core**: UI framework infrastructure shared by all packages (modals, routing, extension system). Use the `add-core-module` skill instead.
+
+## Files to create
+
+```
+src/packages/{package-name}/
+├── package.json                    # npm workspace package
+├── vite.config.ts                  # Build configuration
+├── umbraco-package.ts              # Bundle entry point (lazy-loads manifests)
+├── manifests.ts                    # Aggregates all module manifests
+├── {module-name}/                  # First module
+│   ├── index.ts                   # Public API exports
+│   ├── manifests.ts               # Module manifest registrations
+│   ├── constants.ts               # Module constants
+│   └── types.ts                   # Module types
+```
+
+## Step 1: Create package.json
+
+Every package is an npm workspace. It needs a minimal `package.json`:
+
+```json
+{
+	"name": "@umbraco-backoffice/{package-name}",
+	"version": "0.0.0",
+	"private": true,
+	"type": "module",
+	"scripts": {
+		"build": "vite build"
+	}
+}
+```
+
+## Step 2: Create vite.config.ts
+
+Non-core packages use the simple default config with three entry points (`index.ts`, `manifests.ts`, `umbraco-package.ts`):
+
+```typescript
+import { defineConfig } from 'vite';
+import { rmSync } from 'fs';
+import { getDefaultConfig } from '../../vite-config-base';
+
+const dist = '../../../dist-cms/packages/{package-name}';
+
+// delete the unbundled dist folder
+rmSync(dist, { recursive: true, force: true });
+
+export default defineConfig({
+	...getDefaultConfig({ dist }),
+});
+```
+
+## Step 3: Create umbraco-package.ts
+
+The bundle entry point that lazy-loads the package's manifests:
+
+```typescript
+export const name = 'Umbraco.Core.{PackageName}';
+export const extensions = [
+	{
+		name: '{PackageName} Bundle',
+		alias: 'Umb.Bundle.{PackageName}',
+		type: 'bundle',
+		js: () => import('./manifests.js'),
+	},
+];
+```
+
+Convention: `name` uses `Umbraco.Core.{PascalCaseName}`, alias uses `Umb.Bundle.{PascalCaseName}`.
+
+## Step 4: Create the package-level manifests.ts
+
+Aggregates all module manifests:
+
+```typescript
+import { manifests as {moduleName}Manifests } from './{module-name}/manifests.js';
+
+export const manifests: Array<UmbExtensionManifest> = [
+	...{moduleName}Manifests,
+];
+```
+
+As you add more modules, import and spread their manifests here.
+
+## Step 5: Create the first module
+
+### {module-name}/manifests.ts
+
+```typescript
+export const manifests: Array<UmbExtensionManifest> = [
+	// Extension registrations go here as you build features
+];
+```
+
+### {module-name}/index.ts
+
+```typescript
+// Public API exports — classes, types, constants needed by other packages
+```
+
+### {module-name}/constants.ts
+
+```typescript
+// Module constants — aliases, entity types, context tokens
+```
+
+### {module-name}/types.ts
+
+```typescript
+// Module type definitions — domain models, config interfaces
+```
+
+## Step 6: Register the package
+
+Three registrations are needed to wire the package into the build:
+
+### 1. Add subpath export to root package.json
+
+In `/src/Umbraco.Web.UI.Client/package.json`, add to the `exports` field:
+
+```json
+"./{package-name}": "./dist-cms/packages/{package-name}/index.js"
+```
+
+### 2. Regenerate TypeScript config
+
+```bash
+npm run generate:tsconfig
+```
+
+This updates `tsconfig.json` paths so `@umbraco-cms/backoffice/{package-name}` resolves correctly.
+
+### 3. Install workspace dependencies
+
+```bash
+npm install
+```
+
+This registers the new workspace package with npm.
+
+## Reference: existing packages to study
+
+- **Simple package**: `src/packages/data-type/` — straightforward entity with CRUD
+- **Complex package**: `src/packages/documents/` — multiple modules, rich entity
+- **Minimal package**: `src/packages/tags/` — small feature area
+
+## Checklist
+
+- [ ] `package.json` created with `"type": "module"` and build script
+- [ ] `vite.config.ts` created using `getDefaultConfig()`
+- [ ] `umbraco-package.ts` created with bundle entry point
+- [ ] `manifests.ts` created at package level, aggregating module manifests
+- [ ] First module has `manifests.ts`, `index.ts`, `constants.ts`, `types.ts`
+- [ ] Subpath export added to root `package.json`
+- [ ] `npm run generate:tsconfig` executed
+- [ ] `npm install` executed to register the workspace
+- [ ] Compiles: `npm run compile`
diff --git a/src/Umbraco.Web.UI.Client/.claude/skills/general-create-repository/SKILL.md b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-repository/SKILL.md
new file mode 100644
index 000000000000..200959d69f32
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-repository/SKILL.md
@@ -0,0 +1,609 @@
+---
+name: general-create-repository
+description: Create or extend a repository in the Umbraco backoffice. Covers detail (CRUD), item (batch lookup), collection (paginated list), and action-specific (publish, duplicate, move, etc.) repositories. Use when the user says "create a repository", "add a data source", or when a feature needs to fetch or post data. Each repository type has its own template — pick the right one based on the operation.
+allowed-tools: Read, Write, Edit, Grep, Glob
+---
+
+# Create Repository
+
+Create or extend a repository and its data source for an entity feature in the Umbraco backoffice.
+
+## Foundational documentation
+
+Read these before creating a repository — they define the conventions this skill builds on:
+
+- **[Repositories](../../../docs/repositories.md)** — Repository categories, file structure, naming, extension registration, when to use which type
+- **[Data Flow](../../../docs/data-flow.md)** — Full data flow chain, tryExecute, model mapping, store direction
+- **[Package Development](../../../docs/package-development.md)** — Folder conventions, vertical slices, public API rules
+
+## What you need from the user
+
+1. **Entity name** — singular, kebab-case (e.g., `webhook`, `document`, `data-type`)
+2. **Repository type** — `detail`, `item`, `collection`, or `action-specific`
+3. **Package path** — which package directory (e.g., `src/packages/webhook/webhook/`)
+
+**Additional for action-specific:**
+4. **Action name** — what the operation does (e.g., `duplicate`, `move-to`, `publishing`, `culture-and-hostnames`)
+5. **Methods** — what operations the repository exposes
+
+## Choosing the right type
+
+See [Repositories — When to Create Which](../../../docs/repositories.md#when-to-create-which-repository-type) for the decision matrix.
+
+---
+
+## Option A: Detail Repository
+
+The most common repository type. Handles full CRUD lifecycle with store caching.
+
+### Prerequisites
+
+- Entity type constant in `entity.ts`
+- Detail model type in `types.ts` (must extend `UmbEntityModel` — needs `entityType` and `unique` fields)
+- Generated API client available for the entity
+
+### Files to create
+
+```
+{package-path}/repository/detail/
+├── {entity}-detail.repository.ts
+├── {entity}-detail.server.data-source.ts
+├── {entity}-detail.store.ts
+├── {entity}-detail.store.context-token.ts
+├── constants.ts
+└── manifests.ts
+```
+
+### Step 1: Create store context token
+
+File: `{entity}-detail.store.context-token.ts`
+
+```typescript
+import type { UmbDetailStoreBase } from '@umbraco-cms/backoffice/store';
+import type { Umb{EntityName}DetailModel } from '../../types.js';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+
+export const UMB_{ENTITY}_DETAIL_STORE_CONTEXT = new UmbContextToken<UmbDetailStoreBase<Umb{EntityName}DetailModel>>(
+	'Umb{EntityName}DetailStore',
+);
+```
+
+### Step 2: Create store
+
+File: `{entity}-detail.store.ts`
+
+```typescript
+import type { Umb{EntityName}DetailModel } from '../../types.js';
+import { UMB_{ENTITY}_DETAIL_STORE_CONTEXT } from './{entity}-detail.store.context-token.js';
+import { UmbDetailStoreBase } from '@umbraco-cms/backoffice/store';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+
+export class Umb{EntityName}DetailStore extends UmbDetailStoreBase<Umb{EntityName}DetailModel> {
+	constructor(host: UmbControllerHost) {
+		super(host, UMB_{ENTITY}_DETAIL_STORE_CONTEXT.toString());
+	}
+}
+
+export { Umb{EntityName}DetailStore as api };
+```
+
+### Step 3: Create server data source
+
+File: `{entity}-detail.server.data-source.ts`
+
+The data source maps between server API types and domain models. See [Data Flow](../../../docs/data-flow.md) for context on how this fits in the chain.
+
+```typescript
+import type { Umb{EntityName}DetailModel } from '../../types.js';
+import { UMB_{ENTITY}_ENTITY_TYPE } from '../../entity.js';
+import { UmbId } from '@umbraco-cms/backoffice/id';
+import type { UmbDetailDataSource } from '@umbraco-cms/backoffice/repository';
+import { {EntityName}Service } from '@umbraco-cms/backoffice/external/backend-api';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+
+export class Umb{EntityName}DetailServerDataSource implements UmbDetailDataSource<Umb{EntityName}DetailModel> {
+	#host: UmbControllerHost;
+
+	constructor(host: UmbControllerHost) {
+		this.#host = host;
+	}
+
+	async createScaffold(preset: Partial<Umb{EntityName}DetailModel> = {}) {
+		const data: Umb{EntityName}DetailModel = {
+			entityType: UMB_{ENTITY}_ENTITY_TYPE,
+			unique: UmbId.new(),
+			name: '',
+			// ... defaults for domain-specific properties
+			...preset,
+		};
+		return { data };
+	}
+
+	async read(unique: string) {
+		if (!unique) throw new Error('Unique is missing');
+
+		const { data, error } = await tryExecute(
+			this.#host,
+			{EntityName}Service.get{EntityName}ById({ path: { id: unique } }),
+		);
+
+		if (error || !data) {
+			return { error };
+		}
+
+		const model: Umb{EntityName}DetailModel = {
+			entityType: UMB_{ENTITY}_ENTITY_TYPE,
+			unique: data.id,
+			name: data.name ?? '',
+			// ... map domain-specific properties from server response
+		};
+
+		return { data: model };
+	}
+
+	async create(model: Umb{EntityName}DetailModel, parentUnique: string | null) {
+		if (!model) throw new Error('Model is missing');
+
+		const body = {
+			id: model.unique,
+			name: model.name,
+			// ... map domain-specific properties to server request
+		};
+
+		const { data, error } = await tryExecute(
+			this.#host,
+			{EntityName}Service.post{EntityName}({ body }),
+		);
+
+		if (data) {
+			return this.read(data as never);
+		}
+		return { error };
+	}
+
+	async update(model: Umb{EntityName}DetailModel) {
+		if (!model.unique) throw new Error('Unique is missing');
+
+		const body = {
+			name: model.name,
+			// ... map domain-specific properties to server request
+		};
+
+		const { error } = await tryExecute(
+			this.#host,
+			{EntityName}Service.put{EntityName}ById({ path: { id: model.unique }, body }),
+		);
+
+		if (!error) {
+			return this.read(model.unique);
+		}
+		return { error };
+	}
+
+	async delete(unique: string) {
+		if (!unique) throw new Error('Unique is missing');
+
+		return tryExecute(
+			this.#host,
+			{EntityName}Service.delete{EntityName}ById({ path: { id: unique } }),
+		);
+	}
+}
+```
+
+**Important:** Find the actual generated API service name and method names by checking `@umbraco-cms/backoffice/external/backend-api`. The names above are illustrative — the real generated service may differ.
+
+### Step 4: Create repository
+
+File: `{entity}-detail.repository.ts`
+
+```typescript
+import type { Umb{EntityName}DetailModel } from '../../types.js';
+import { Umb{EntityName}DetailServerDataSource } from './{entity}-detail.server.data-source.js';
+import { UMB_{ENTITY}_DETAIL_STORE_CONTEXT } from './{entity}-detail.store.context-token.js';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbDetailRepositoryBase } from '@umbraco-cms/backoffice/repository';
+
+export class Umb{EntityName}DetailRepository extends UmbDetailRepositoryBase<Umb{EntityName}DetailModel> {
+	constructor(host: UmbControllerHost) {
+		super(host, Umb{EntityName}DetailServerDataSource, UMB_{ENTITY}_DETAIL_STORE_CONTEXT);
+	}
+}
+
+export { Umb{EntityName}DetailRepository as api };
+```
+
+### Step 5: Create constants
+
+File: `constants.ts`
+
+```typescript
+export const UMB_{ENTITY}_DETAIL_REPOSITORY_ALIAS = 'Umb.Repository.{EntityName}.Detail';
+export const UMB_{ENTITY}_DETAIL_STORE_ALIAS = 'Umb.Store.{EntityName}.Detail';
+```
+
+### Step 6: Create manifests
+
+File: `manifests.ts`
+
+```typescript
+import { UMB_{ENTITY}_DETAIL_REPOSITORY_ALIAS, UMB_{ENTITY}_DETAIL_STORE_ALIAS } from './constants.js';
+import { Umb{EntityName}DetailStore } from './{entity}-detail.store.js';
+
+export const manifests: Array<UmbExtensionManifest> = [
+	{
+		type: 'repository',
+		alias: UMB_{ENTITY}_DETAIL_REPOSITORY_ALIAS,
+		name: '{EntityName} Detail Repository',
+		api: () => import('./{entity}-detail.repository.js'),
+	},
+	{
+		type: 'store',
+		alias: UMB_{ENTITY}_DETAIL_STORE_ALIAS,
+		name: '{EntityName} Detail Store',
+		api: Umb{EntityName}DetailStore,
+	},
+];
+```
+
+### Step 7: Wire manifests into parent
+
+Import and spread in the parent module's `manifests.ts`:
+
+```typescript
+import { manifests as detailRepositoryManifests } from './repository/detail/manifests.js';
+
+export const manifests: Array<UmbExtensionManifest> = [
+	...detailRepositoryManifests,
+	// ... other manifests
+];
+```
+
+### Detail repository checklist
+
+- [ ] Detail model type exists in `types.ts` with `entityType` and `unique` fields
+- [ ] Entity type constant exists in `entity.ts`
+- [ ] Store context token created
+- [ ] Store class extends `UmbDetailStoreBase<T>`
+- [ ] Data source implements `UmbDetailDataSource<T>` with all 5 methods
+- [ ] Data source maps server types ↔ domain model in both directions
+- [ ] Data source uses `tryExecute()` for all API calls
+- [ ] Repository extends `UmbDetailRepositoryBase<T>`, passing data source class + store context
+- [ ] Repository and store exported as `api` (for lazy-loading)
+- [ ] Manifest aliases defined as constants
+- [ ] Manifests registered with `type: 'repository'` and `type: 'store'`
+- [ ] Manifests wired into parent module's `manifests.ts`
+
+---
+
+## Option B: Item Repository
+
+For batch-fetching lightweight display info (name, icon, entity type) by unique IDs. Used by pickers, reference lists, and breadcrumbs.
+
+### Prerequisites
+
+- Item model type in `types.ts` (needs `unique` field)
+- Generated API client with a batch/list endpoint
+
+### Files to create
+
+```
+{package-path}/item/repository/
+├── {entity}-item.repository.ts
+├── {entity}-item.server.data-source.ts
+├── {entity}-item.store.ts
+├── {entity}-item.store.context-token.ts
+├── constants.ts
+└── manifests.ts
+```
+
+### Step 1: Create item store context token
+
+File: `{entity}-item.store.context-token.ts`
+
+```typescript
+import type { UmbItemStore } from '@umbraco-cms/backoffice/store';
+import type { Umb{EntityName}ItemModel } from '../../types.js';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+
+export const UMB_{ENTITY}_ITEM_STORE_CONTEXT = new UmbContextToken<UmbItemStore<Umb{EntityName}ItemModel>>(
+	'Umb{EntityName}ItemStore',
+);
+```
+
+### Step 2: Create item store
+
+File: `{entity}-item.store.ts`
+
+```typescript
+import type { Umb{EntityName}ItemModel } from '../../types.js';
+import { UMB_{ENTITY}_ITEM_STORE_CONTEXT } from './{entity}-item.store.context-token.js';
+import { UmbItemStoreBase } from '@umbraco-cms/backoffice/store';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+
+export class Umb{EntityName}ItemStore extends UmbItemStoreBase<Umb{EntityName}ItemModel> {
+	constructor(host: UmbControllerHost) {
+		super(host, UMB_{ENTITY}_ITEM_STORE_CONTEXT.toString());
+	}
+}
+
+export { Umb{EntityName}ItemStore as api };
+```
+
+### Step 3: Create item server data source
+
+File: `{entity}-item.server.data-source.ts`
+
+```typescript
+import type { Umb{EntityName}ItemModel } from '../../types.js';
+import { UMB_{ENTITY}_ENTITY_TYPE } from '../../entity.js';
+import { UmbItemServerDataSourceBase } from '@umbraco-cms/backoffice/repository';
+import type { {EntityName}ItemResponseModel } from '@umbraco-cms/backoffice/external/backend-api';
+import { {EntityName}Service } from '@umbraco-cms/backoffice/external/backend-api';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+
+export class Umb{EntityName}ItemServerDataSource extends UmbItemServerDataSourceBase<
+	{EntityName}ItemResponseModel,
+	Umb{EntityName}ItemModel
+> {
+	constructor(host: UmbControllerHost) {
+		super(host, {
+			getItems: (uniques) => {EntityName}Service.getItem{EntityName}({ query: { id: uniques } }),
+			mapper: (item) => ({
+				entityType: UMB_{ENTITY}_ENTITY_TYPE,
+				unique: item.id,
+				name: item.name ?? '',
+				// ... map domain-specific item properties
+			}),
+		});
+	}
+}
+```
+
+### Step 4: Create item repository
+
+File: `{entity}-item.repository.ts`
+
+```typescript
+import type { Umb{EntityName}ItemModel } from '../../types.js';
+import { Umb{EntityName}ItemServerDataSource } from './{entity}-item.server.data-source.js';
+import { UMB_{ENTITY}_ITEM_STORE_CONTEXT } from './{entity}-item.store.context-token.js';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbItemRepositoryBase } from '@umbraco-cms/backoffice/repository';
+
+export class Umb{EntityName}ItemRepository extends UmbItemRepositoryBase<Umb{EntityName}ItemModel> {
+	constructor(host: UmbControllerHost) {
+		super(host, Umb{EntityName}ItemServerDataSource, UMB_{ENTITY}_ITEM_STORE_CONTEXT);
+	}
+}
+
+export { Umb{EntityName}ItemRepository as api };
+```
+
+### Step 5: Create constants and manifests
+
+Follow the same pattern as detail (Step 5–6), using `Item` instead of `Detail` in aliases.
+
+### Item repository checklist
+
+- [ ] Item model type exists in `types.ts` with `unique` field
+- [ ] Store context token, store class, data source, and repository created
+- [ ] Data source extends `UmbItemServerDataSourceBase` with `getItems` and `mapper`
+- [ ] Repository extends `UmbItemRepositoryBase<T>`
+- [ ] Manifests registered and wired into parent
+
+---
+
+## Option C: Collection Repository
+
+For paginated/filtered listings. No base class — implement the `UmbCollectionRepository` interface on `UmbRepositoryBase`.
+
+### Files to create
+
+```
+{package-path}/collection/repository/
+├── {entity}-collection.repository.ts
+├── {entity}-collection.server.data-source.ts
+└── manifests.ts
+```
+
+### Step 1: Create collection server data source
+
+File: `{entity}-collection.server.data-source.ts`
+
+```typescript
+import type { Umb{EntityName}CollectionFilterModel } from '../types.js';
+import { {EntityName}Service } from '@umbraco-cms/backoffice/external/backend-api';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+
+export class Umb{EntityName}CollectionServerDataSource {
+	#host: UmbControllerHost;
+
+	constructor(host: UmbControllerHost) {
+		this.#host = host;
+	}
+
+	async getCollection(filter: Umb{EntityName}CollectionFilterModel) {
+		const { data, error } = await tryExecute(
+			this.#host,
+			{EntityName}Service.get{EntityName}({ query: { skip: filter.skip, take: filter.take } }),
+		);
+
+		if (error || !data) {
+			return { error };
+		}
+
+		return {
+			data: {
+				items: data.items.map((item) => ({
+					// ... map to collection item model
+				})),
+				total: data.total,
+			},
+		};
+	}
+}
+```
+
+### Step 2: Create collection repository
+
+File: `{entity}-collection.repository.ts`
+
+```typescript
+import { Umb{EntityName}CollectionServerDataSource } from './{entity}-collection.server.data-source.js';
+import type { Umb{EntityName}CollectionFilterModel } from '../types.js';
+import { UmbRepositoryBase } from '@umbraco-cms/backoffice/repository';
+import type { UmbCollectionRepository } from '@umbraco-cms/backoffice/collection';
+
+export class Umb{EntityName}CollectionRepository
+	extends UmbRepositoryBase
+	implements UmbCollectionRepository
+{
+	#collectionSource = new Umb{EntityName}CollectionServerDataSource(this);
+
+	async requestCollection(filter: Umb{EntityName}CollectionFilterModel) {
+		return this.#collectionSource.getCollection(filter);
+	}
+}
+
+export { Umb{EntityName}CollectionRepository as api };
+```
+
+### Collection repository checklist
+
+- [ ] Collection filter model type defined
+- [ ] Data source maps server response to collection item models
+- [ ] Repository implements `UmbCollectionRepository` interface
+- [ ] Manifests registered and wired into parent
+
+---
+
+## Option D: Action-Specific Repository
+
+For domain operations that don't fit CRUD — publish, duplicate, move, sort, recycle bin, etc.
+
+### Prerequisites
+
+- Entity type constant
+- Generated API client with the relevant endpoint
+
+### Files to create
+
+```
+{package-path}/{action-location}/repository/
+├── {entity}-{action}.repository.ts
+├── {entity}-{action}.server.data-source.ts
+├── types.ts                              # Optional — args/response types
+└── manifests.ts
+```
+
+**Location rules:**
+- Entity actions: `entity-actions/{action-name}/repository/`
+- Bulk actions: `entity-bulk-actions/{action-name}/repository/`
+- Domain sub-features: `{feature-name}/repository/` (e.g., `publishing/repository/`)
+
+### Step 1: Create types (if needed)
+
+File: `types.ts`
+
+```typescript
+export interface Umb{Action}{EntityName}RequestArgs {
+	unique: string;
+	// ... action-specific arguments
+}
+```
+
+### Step 2: Create server data source
+
+File: `{entity}-{action}.server.data-source.ts`
+
+```typescript
+import type { Umb{Action}{EntityName}RequestArgs } from './types.js';
+import { {EntityName}Service } from '@umbraco-cms/backoffice/external/backend-api';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+
+export class Umb{Action}{EntityName}ServerDataSource {
+	#host: UmbControllerHost;
+
+	constructor(host: UmbControllerHost) {
+		this.#host = host;
+	}
+
+	async {actionMethod}(args: Umb{Action}{EntityName}RequestArgs) {
+		if (!args.unique) throw new Error('Unique is missing');
+
+		return tryExecute(
+			this.#host,
+			{EntityName}Service.{apiMethod}({
+				path: { id: args.unique },
+				body: {
+					// ... map args to server request
+				},
+			}),
+		);
+	}
+}
+```
+
+### Step 3: Create repository
+
+File: `{entity}-{action}.repository.ts`
+
+```typescript
+import { Umb{Action}{EntityName}ServerDataSource } from './{entity}-{action}.server.data-source.js';
+import type { Umb{Action}{EntityName}RequestArgs } from './types.js';
+import { UMB_NOTIFICATION_CONTEXT } from '@umbraco-cms/backoffice/notification';
+import { UmbRepositoryBase } from '@umbraco-cms/backoffice/repository';
+
+export class Umb{Action}{EntityName}Repository extends UmbRepositoryBase {
+	#{action}Source = new Umb{Action}{EntityName}ServerDataSource(this);
+
+	async request{Action}(args: Umb{Action}{EntityName}RequestArgs) {
+		const { data, error } = await this.#{action}Source.{actionMethod}(args);
+
+		if (!error) {
+			const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
+			const notification = { data: { message: `{Action} completed` } };
+			notificationContext.peek('positive', notification);
+		}
+
+		return { data, error };
+	}
+}
+
+export { Umb{Action}{EntityName}Repository as api };
+```
+
+### Step 4: Create manifests
+
+File: `manifests.ts`
+
+```typescript
+export const manifests: Array<UmbExtensionManifest> = [
+	{
+		type: 'repository',
+		alias: 'Umb.Repository.{EntityName}.{Action}',
+		name: '{EntityName} {Action} Repository',
+		api: () => import('./{entity}-{action}.repository.js'),
+	},
+];
+```
+
+### Action-specific repository checklist
+
+- [ ] Args type defined (if the action has parameters beyond unique)
+- [ ] Data source handles API call with `tryExecute()`
+- [ ] Repository extends `UmbRepositoryBase` or `UmbControllerBase`
+- [ ] Repository methods validate required arguments
+- [ ] Success notification shown where appropriate
+- [ ] Repository exported as `api` for lazy-loading
+- [ ] Manifest registered and wired into parent
+
+---
+
+## Reference examples
+
+See [Repositories — Reference Examples](../../../docs/repositories.md#reference-examples) for real implementations to study.
diff --git a/src/Umbraco.Web.UI.Client/.claude/skills/general-create-workspace/SKILL.md b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-workspace/SKILL.md
new file mode 100644
index 000000000000..7d6e5bec596c
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/.claude/skills/general-create-workspace/SKILL.md
@@ -0,0 +1,445 @@
+---
+name: general-create-workspace
+description: Create a new workspace for an entity in the Umbraco backoffice. Supports two workspace types — default (simple, manifest-only, for root/listing pages) and routable (entity detail editing with create/edit flows). Use when the user says "create a workspace", "add a workspace for X", or "scaffold a workspace". For routable workspaces, the entity must already have a package, entity type, repository, and data source.
+allowed-tools: Read, Write, Edit, Grep, Glob
+---
+
+# Create Workspace
+
+Create a workspace in the Umbraco backoffice. Two workspace types are available:
+
+- **Default workspace** — manifest-only, no custom code. For root pages, listing pages, settings.
+- **Routable workspace** — custom context class with create/edit URL routing. For entity detail editing with full CRUD lifecycle.
+
+## What you need from the user
+
+1. **Workspace type** — `default` (root/listing) or `routable` (entity detail editing)
+2. **Entity name** — singular, kebab-case (e.g., `webhook`, `data-type`, `language`)
+3. **Package path** — which package directory (e.g., `src/packages/webhook/webhook/`)
+
+**Additional for routable workspaces:**
+4. **Has parent entity** — whether creation requires a parent (tree entities like data-type) or not (flat entities like webhook)
+5. **Entity properties** — what observable properties the workspace should expose beyond `name` and `unique`
+
+---
+
+## Option A: Default Workspace
+
+The simplest workspace. Just a manifest — no custom context class or element. The `default` kind provides `UmbDefaultWorkspaceContext` and `<umb-default-workspace>` automatically.
+
+### Prerequisites
+
+- Entity type constant in `entity.ts` (e.g., `UMB_WEBHOOK_ROOT_ENTITY_TYPE`)
+- Workspace alias constant (e.g., `UMB_WEBHOOK_ROOT_WORKSPACE_ALIAS`)
+
+### Files to create
+
+Just a `manifests.ts` (can be in an existing manifests file or a new `workspace/` directory):
+
+```typescript
+import { UMB_{ENTITY}_ROOT_ENTITY_TYPE } from '../../entity.js';
+import { UMB_{ENTITY}_ROOT_WORKSPACE_ALIAS } from './constants.js';
+import { UMB_WORKSPACE_CONDITION_ALIAS } from '@umbraco-cms/backoffice/workspace';
+
+export const manifests: Array<UmbExtensionManifest> = [
+	{
+		type: 'workspace',
+		kind: 'default',
+		alias: UMB_{ENTITY}_ROOT_WORKSPACE_ALIAS,
+		name: '{EntityName} Root Workspace',
+		meta: {
+			entityType: UMB_{ENTITY}_ROOT_ENTITY_TYPE,
+			headline: '#treeHeaders_{entityPlural}',
+		},
+	},
+	// Optional: add a collection view to list child entities
+	{
+		type: 'workspaceView',
+		kind: 'collection',
+		alias: 'Umb.WorkspaceView.{EntityName}Root.Collection',
+		name: '{EntityName} Root Collection Workspace View',
+		meta: {
+			label: 'Collection',
+			pathname: 'collection',
+			icon: 'icon-layers',
+			collectionAlias: UMB_{ENTITY}_COLLECTION_ALIAS,
+		},
+		conditions: [
+			{
+				alias: UMB_WORKSPACE_CONDITION_ALIAS,
+				match: UMB_{ENTITY}_ROOT_WORKSPACE_ALIAS,
+			},
+		],
+	},
+];
+```
+
+### Default workspace checklist
+
+- [ ] Workspace alias constant defined
+- [ ] Entity type constant defined
+- [ ] Manifest has `kind: 'default'`, `meta.entityType`, and `meta.headline`
+- [ ] Workspace views use `UMB_WORKSPACE_CONDITION_ALIAS` condition
+- [ ] Manifests wired into parent module's `manifests.ts`
+
+---
+
+## Option B: Routable Workspace (Entity Detail)
+
+For entity detail editing with create/edit URL routing, validation, save flow, and data management.
+
+### Prerequisites
+
+Before creating a routable workspace, the entity must already have:
+
+- Entity type constants in `entity.ts` (constant + root entity type + workspace alias)
+- Detail model type (e.g., `UmbWebhookDetailModel`) in `types.ts`
+- Detail repository + data source + store (see [Data Flow](../../../docs/data-flow.md))
+- Repository manifest registered
+
+Verify these exist before proceeding. If the package doesn't exist yet, use the `general-create-package` skill first.
+
+### Files to create
+
+```
+{package-path}/workspace/
+├── constants.ts                              # Re-export context token
+├── {entity}-workspace.context-token.ts       # Typed context token
+├── {entity}-workspace.context.ts             # Workspace context class
+├── {entity}-workspace-editor.element.ts      # Editor shell element
+├── manifests.ts                              # workspace + workspaceView + workspaceAction
+└── views/
+    └── {entity}-details-workspace-view.element.ts  # Main detail view
+```
+
+## Step 1: Create context token
+
+File: `{entity}-workspace.context-token.ts`
+
+```typescript
+import type { Umb{EntityName}WorkspaceContext } from './{entity}-workspace.context.js';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import type { UmbSubmittableWorkspaceContext } from '@umbraco-cms/backoffice/workspace';
+
+export const UMB_{ENTITY}_WORKSPACE_CONTEXT = new UmbContextToken<
+	UmbSubmittableWorkspaceContext,
+	Umb{EntityName}WorkspaceContext
+>(
+	'UmbWorkspaceContext',
+	undefined,
+	(context): context is Umb{EntityName}WorkspaceContext => context.getEntityType?.() === '{entity-type}',
+);
+```
+
+## Step 2: Create constants.ts
+
+File: `constants.ts`
+
+```typescript
+export { UMB_{ENTITY}_WORKSPACE_CONTEXT } from './{entity}-workspace.context-token.js';
+```
+
+## Step 3: Create workspace context
+
+File: `{entity}-workspace.context.ts`
+
+### Variant A: Simple (no parent hierarchy, like webhook)
+
+```typescript
+import type { Umb{EntityName}DetailRepository } from '../repository/index.js';
+import { UMB_{ENTITY}_DETAIL_REPOSITORY_ALIAS } from '../repository/index.js';
+import { UMB_{ENTITY}_ENTITY_TYPE, UMB_{ENTITY}_ROOT_ENTITY_TYPE, UMB_{ENTITY}_WORKSPACE_ALIAS } from '../../entity.js';
+import type { Umb{EntityName}DetailModel } from '../types.js';
+import { Umb{EntityName}WorkspaceEditorElement } from './{entity}-workspace-editor.element.js';
+import {
+	UmbEntityNamedDetailWorkspaceContextBase,
+	UmbWorkspaceIsNewRedirectController,
+	UmbWorkspaceIsNewRedirectControllerAlias,
+} from '@umbraco-cms/backoffice/workspace';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import type { UmbSubmittableWorkspaceContext, UmbRoutableWorkspaceContext } from '@umbraco-cms/backoffice/workspace';
+
+export class Umb{EntityName}WorkspaceContext
+	extends UmbEntityNamedDetailWorkspaceContextBase<Umb{EntityName}DetailModel, Umb{EntityName}DetailRepository>
+	implements UmbSubmittableWorkspaceContext, UmbRoutableWorkspaceContext
+{
+	// Observable properties — add one per entity property
+	// readonly myProp = this._data.createObservablePartOfCurrent((data) => data?.myProp);
+
+	constructor(host: UmbControllerHost) {
+		super(host, {
+			workspaceAlias: UMB_{ENTITY}_WORKSPACE_ALIAS,
+			entityType: UMB_{ENTITY}_ENTITY_TYPE,
+			detailRepositoryAlias: UMB_{ENTITY}_DETAIL_REPOSITORY_ALIAS,
+		});
+
+		this.routes.setRoutes([
+			{
+				path: 'create',
+				component: Umb{EntityName}WorkspaceEditorElement,
+				setup: async () => {
+					await this.createScaffold({ parent: { entityType: UMB_{ENTITY}_ROOT_ENTITY_TYPE, unique: null } });
+
+					new UmbWorkspaceIsNewRedirectController(
+						this,
+						this,
+						this.getHostElement().shadowRoot!.querySelector('umb-router-slot')!,
+					);
+				},
+			},
+			{
+				path: 'edit/:unique',
+				component: Umb{EntityName}WorkspaceEditorElement,
+				setup: (_component, info) => {
+					this.removeUmbControllerByAlias(UmbWorkspaceIsNewRedirectControllerAlias);
+					this.load(info.match.params.unique);
+				},
+			},
+		]);
+	}
+
+	// Getter/setter methods — add one pair per entity property
+	// getMyProp(): string | undefined {
+	// 	return this._data.getCurrent()?.myProp;
+	// }
+	// setMyProp(value: string) {
+	// 	this._data.updateCurrent({ myProp: value });
+	// }
+}
+
+export { Umb{EntityName}WorkspaceContext as api };
+```
+
+### Variant B: Parent-aware (tree entities, like data-type)
+
+Replace the `create` route with:
+
+```typescript
+{
+	path: 'create/parent/:entityType/:parentUnique',
+	component: Umb{EntityName}WorkspaceEditorElement,
+	setup: async (_component, info) => {
+		const parentEntityType = info.match.params.entityType;
+		const parentUnique = info.match.params.parentUnique === 'null' ? null : info.match.params.parentUnique;
+		await this.createScaffold({ parent: { entityType: parentEntityType, unique: parentUnique } });
+
+		new UmbWorkspaceIsNewRedirectController(
+			this,
+			this,
+			this.getHostElement().shadowRoot!.querySelector('umb-router-slot')!,
+		);
+	},
+},
+```
+
+## Step 4: Create editor element
+
+File: `{entity}-workspace-editor.element.ts`
+
+Uses `<umb-workspace-header-name-editable>` — a built-in element that auto-consumes the workspace context for name binding, validation, write guard permissions, and auto-focus. No manual name wiring needed.
+
+```typescript
+import { css, html, customElement } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+
+// Back path: find or create a constant like UMB_{ENTITY}_SECTION_PATH in the entity's section-path constants.
+// Grep for 'SECTION_PATH' or 'WORKSPACE_PATH' in the entity's package to find the correct import.
+const BACK_PATH = 'FIXME: replace with section path constant';
+
+@customElement('umb-{entity}-workspace-editor')
+export class Umb{EntityName}WorkspaceEditorElement extends UmbLitElement {
+	override render() {
+		return html`
+			<umb-entity-detail-workspace-editor back-path=${BACK_PATH}>
+				<umb-workspace-header-name-editable slot="header"></umb-workspace-header-name-editable>
+			</umb-entity-detail-workspace-editor>
+		`;
+	}
+
+	static override styles = [
+		css`
+			:host {
+				display: block;
+				width: 100%;
+				height: 100%;
+			}
+		`,
+	];
+}
+
+export { Umb{EntityName}WorkspaceEditorElement as element };
+
+declare global {
+	interface HTMLElementTagNameMap {
+		'umb-{entity}-workspace-editor': Umb{EntityName}WorkspaceEditorElement;
+	}
+}
+```
+
+## Step 5: Create detail view element
+
+File: `views/{entity}-details-workspace-view.element.ts`
+
+```typescript
+import { UMB_{ENTITY}_WORKSPACE_CONTEXT } from '../{entity}-workspace.context-token.js';
+import type { Umb{EntityName}DetailModel } from '../../types.js';
+import { css, customElement, html, state, nothing } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
+import type { UmbWorkspaceViewElement } from '@umbraco-cms/backoffice/workspace';
+
+@customElement('umb-{entity}-details-workspace-view')
+export class Umb{EntityName}DetailsWorkspaceViewElement extends UmbLitElement implements UmbWorkspaceViewElement {
+	@state()
+	private _data?: Umb{EntityName}DetailModel;
+
+	#workspaceContext?: typeof UMB_{ENTITY}_WORKSPACE_CONTEXT.TYPE;
+
+	constructor() {
+		super();
+
+		this.consumeContext(UMB_{ENTITY}_WORKSPACE_CONTEXT, (context) => {
+			this.#workspaceContext = context;
+			this.observe(this.#workspaceContext?.data, (data) => {
+				this._data = data;
+			});
+		});
+	}
+
+	override render() {
+		if (!this._data) return nothing;
+
+		return html`
+			<uui-box>
+				<!-- Add umb-property-layout elements for each property -->
+				<!-- Example:
+				<umb-property-layout label="My Property">
+					<uui-input
+						slot="editor"
+						.value=${this._data.myProp ?? ''}
+						@input=${(e: InputEvent) => this.#workspaceContext?.setMyProp((e.target as HTMLInputElement).value)}>
+					</uui-input>
+				</umb-property-layout>
+				-->
+			</uui-box>
+		`;
+	}
+
+	static override styles = [
+		UmbTextStyles,
+		css`
+			:host {
+				display: block;
+				padding: var(--uui-size-space-6);
+			}
+
+			uui-input {
+				width: 100%;
+			}
+
+			umb-property-layout:first-child {
+				padding-top: 0;
+			}
+			umb-property-layout:last-child {
+				padding-bottom: 0;
+			}
+		`,
+	];
+}
+
+export { Umb{EntityName}DetailsWorkspaceViewElement as element };
+
+declare global {
+	interface HTMLElementTagNameMap {
+		'umb-{entity}-details-workspace-view': Umb{EntityName}DetailsWorkspaceViewElement;
+	}
+}
+```
+
+## Step 6: Create manifests
+
+File: `manifests.ts`
+
+```typescript
+import { UMB_{ENTITY}_ENTITY_TYPE, UMB_{ENTITY}_WORKSPACE_ALIAS } from '../../entity.js';
+import { UMB_WORKSPACE_CONDITION_ALIAS, UmbSubmitWorkspaceAction } from '@umbraco-cms/backoffice/workspace';
+
+export const manifests: Array<UmbExtensionManifest> = [
+	{
+		type: 'workspace',
+		kind: 'routable',
+		alias: UMB_{ENTITY}_WORKSPACE_ALIAS,
+		name: '{EntityName} Workspace',
+		api: () => import('./{entity}-workspace.context.js'),
+		meta: {
+			entityType: UMB_{ENTITY}_ENTITY_TYPE,
+		},
+	},
+	{
+		type: 'workspaceView',
+		alias: 'Umb.WorkspaceView.{EntityName}.Details',
+		name: '{EntityName} Workspace Details View',
+		element: () => import('./views/{entity}-details-workspace-view.element.js'),
+		weight: 90,
+		meta: {
+			label: '#general_details',
+			pathname: 'details',
+			icon: 'edit',
+		},
+		conditions: [
+			{
+				alias: UMB_WORKSPACE_CONDITION_ALIAS,
+				match: UMB_{ENTITY}_WORKSPACE_ALIAS,
+			},
+		],
+	},
+	{
+		type: 'workspaceAction',
+		kind: 'default',
+		alias: 'Umb.WorkspaceAction.{EntityName}.Save',
+		name: 'Save {EntityName} Workspace Action',
+		api: UmbSubmitWorkspaceAction,
+		meta: {
+			label: '#buttons_save',
+			look: 'primary',
+			color: 'positive',
+		},
+		conditions: [
+			{
+				alias: UMB_WORKSPACE_CONDITION_ALIAS,
+				match: UMB_{ENTITY}_WORKSPACE_ALIAS,
+			},
+		],
+	},
+];
+```
+
+## Step 7: Wire manifests into parent module
+
+Import and spread the workspace manifests in the parent module's `manifests.ts`:
+
+```typescript
+import { manifests as workspaceManifests } from './workspace/manifests.js';
+
+export const manifests: Array<UmbExtensionManifest> = [
+	...workspaceManifests,
+	// ... other manifests
+];
+```
+
+## Routable workspace checklist
+
+- [ ] Context token file with correct discriminator (`getEntityType()` check)
+- [ ] `constants.ts` re-exports context token
+- [ ] Workspace context extends `UmbEntityNamedDetailWorkspaceContextBase`
+- [ ] Workspace context exported as `api` (last line)
+- [ ] Routes set up with `create` and `edit/:unique` paths
+- [ ] `UmbWorkspaceIsNewRedirectController` used in create route
+- [ ] Editor element uses `<umb-entity-detail-workspace-editor>` with `<umb-workspace-header-name-editable slot="header">`
+- [ ] Editor element exports as `element` and declared on `HTMLElementTagNameMap`
+- [ ] View element implements `UmbWorkspaceViewElement`
+- [ ] View element exports as `element` and declared on `HTMLElementTagNameMap`
+- [ ] Manifests include `workspace`, `workspaceView`, and `workspaceAction`
+- [ ] All view/action manifests use `UMB_WORKSPACE_CONDITION_ALIAS` condition
+- [ ] Workspace manifests wired into parent module's `manifests.ts`
+- [ ] Back path constant set correctly in editor element
diff --git a/src/Umbraco.Web.UI.Client/.claude/skills/general-deprecate-api/SKILL.md b/src/Umbraco.Web.UI.Client/.claude/skills/general-deprecate-api/SKILL.md
new file mode 100644
index 000000000000..428bf726010b
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/.claude/skills/general-deprecate-api/SKILL.md
@@ -0,0 +1,158 @@
+---
+name: general-deprecate-api
+description: Deprecate a public API (class, method, property, type, constant, or context token) following the 2-major-version rule. Use when removing or replacing any publicly exported symbol that external consumers may depend on — includes exports from package index.ts files, global components, extension type aliases, and manifest schemas.
+allowed-tools: Read, Write, Edit, Grep, Glob
+---
+
+# Deprecate API
+
+Deprecate a public API following Umbraco's breaking changes policy.
+
+## What you need from the user
+
+1. **What to deprecate** — The class, method, property, type, or constant
+2. **The replacement** — What consumers should use instead
+3. **Current major version** — Read from `version.json` at the repository root
+
+## The 2-Major-Version Rule
+
+> Deprecated in **vN** -> earliest removal in **vN+2**.
+>
+> Example: deprecated in v17 -> scheduled for removal in v19.
+
+Read `version.json` to determine the current major version and calculate the removal version.
+
+## Both mechanisms are required
+
+Every deprecation **must** use both:
+
+1. **JSDoc `@deprecated` tag** — for IDE warnings and documentation
+2. **`UmbDeprecation` runtime warning** — for console output at runtime
+
+## Step 1: Add the replacement API
+
+Introduce the new API alongside the old one. The old API should delegate to the new implementation internally.
+
+```typescript
+// New method (the replacement)
+requestSummary() {
+	// Real implementation here
+}
+```
+
+## Step 2: Add JSDoc `@deprecated` tag
+
+Include: what was deprecated, when, the replacement, and when it will be removed.
+
+```typescript
+/**
+ * @deprecated Deprecated since v17. Use `requestSummary()` instead. Will be removed in v19.
+ */
+getSummary() {
+	return this.requestSummary();
+}
+```
+
+For types and interfaces:
+
+```typescript
+/**
+ * @deprecated Deprecated since v17. Use `UmbNewInterface` instead. Scheduled for removal in Umbraco 19.
+ */
+export interface UmbOldInterface {
+	// ...
+}
+```
+
+## Step 3: Add `UmbDeprecation` runtime warning
+
+```typescript
+import { UmbDeprecation } from '@umbraco-cms/backoffice/utils';
+
+/**
+ * @deprecated Deprecated since v17. Use `requestSummary()` instead. Will be removed in v19.
+ */
+getSummary() {
+	new UmbDeprecation({
+		deprecated: 'UmbMyContext.getSummary()',
+		removeInVersion: '19.0.0',
+		solution: 'Use requestSummary() instead.',
+	}).warn();
+
+	return this.requestSummary();
+}
+```
+
+### Placement by symbol type
+
+| Symbol | Where to place `UmbDeprecation` |
+|--------|-------------------------------|
+| Method | Inside the method body |
+| Class | In the `constructor` |
+| Property getter | Inside the getter |
+| Constant | At module level (executes on import) |
+
+### For deprecated classes
+
+```typescript
+/**
+ * @deprecated Deprecated since v17. Use `UmbNewRepository` instead. Will be removed in v19.
+ */
+export class UmbOldRepository extends UmbControllerBase {
+	constructor(host: UmbControllerHost) {
+		super(host);
+
+		new UmbDeprecation({
+			deprecated: 'UmbOldRepository is deprecated.',
+			removeInVersion: '19.0.0',
+			solution: 'Use UmbNewRepository instead.',
+		}).warn();
+	}
+}
+```
+
+## Step 4: Delegate old to new
+
+The deprecated API must keep working. Delegate to the replacement internally:
+
+```typescript
+/**
+ * @deprecated Deprecated since v17. Use `getContentTypeUnique()` instead. Will be removed in v19.
+ */
+getContentTypeId(): string | undefined {
+	new UmbDeprecation({
+		deprecated: 'UmbMemberWorkspaceContext.getContentTypeId()',
+		removeInVersion: '19.0.0',
+		solution: 'Use getContentTypeUnique() instead.',
+	}).warn();
+
+	return this.getContentTypeUnique();
+}
+```
+
+## Step 5: Update internal callers
+
+All internal code must use the new API. No code within the repository should call the deprecated member.
+
+## What counts as a breaking change
+
+Any of the following to a **publicly exported** symbol:
+
+- Removing/renaming an exported class, function, type, constant, or context token
+- Removing/renaming a public method or property
+- Changing a public method signature (required params, return type)
+- Removing/renaming a subpath export from `package.json`
+- Changing an extension type alias or manifest schema
+- Removing/renaming a global component's tag name
+
+**Not breaking**: Internal code (unexported classes, private methods) can be changed freely without deprecation.
+
+## Checklist
+
+- [ ] Replacement API introduced and working
+- [ ] `@deprecated` JSDoc tag added with: since version, replacement, removal version
+- [ ] `UmbDeprecation` runtime warning added with `deprecated`, `removeInVersion`, `solution`
+- [ ] Deprecated code delegates to the replacement (still works)
+- [ ] All internal callers updated to use the new API
+- [ ] Removal version follows the 2-major-version rule (current + 2)
+- [ ] Compiles: `npm run compile`
diff --git a/src/Umbraco.Web.UI.Client/.nvmrc b/src/Umbraco.Web.UI.Client/.nvmrc
index 2bd5a0a98a36..a45fd52cc589 100644
--- a/src/Umbraco.Web.UI.Client/.nvmrc
+++ b/src/Umbraco.Web.UI.Client/.nvmrc
@@ -1 +1 @@
-22
+24
diff --git a/src/Umbraco.Web.UI.Client/.storybook/preview.js b/src/Umbraco.Web.UI.Client/.storybook/preview.js
index fab4109ac71f..86c560713019 100644
--- a/src/Umbraco.Web.UI.Client/.storybook/preview.js
+++ b/src/Umbraco.Web.UI.Client/.storybook/preview.js
@@ -1,4 +1,6 @@
-import '@umbraco-ui/uui-css/dist/uui-css.css';
+import lightCss from '@umbraco-ui/uui/themes/light.css?inline';
+import darkCss from '@umbraco-ui/uui/themes/dark.css?inline';
+import highContrastCss from '@umbraco-ui/uui/themes/high-contrast.css?inline';
 import '../src/css/umb-css.css';
 
 import 'element-internals-polyfill';
@@ -70,6 +72,39 @@ import { UMB_APP_LANGUAGE_CONTEXT } from '../src/packages/language/constants';
 // MSW
 startMockServiceWorker({ serviceWorker: { url: (import.meta.env.VITE_BASE_PATH ?? '/') + 'mockServiceWorker.js' } });
 
+const themes = {
+	light: lightCss,
+	dark: darkCss,
+	'high-contrast': highContrastCss,
+};
+
+let themeStyleEl = null;
+
+export const globalTypes = {
+	theme: {
+		name: 'Theme',
+		defaultValue: 'light',
+		toolbar: {
+			icon: 'paintbrush',
+			items: [
+				{ value: 'light', title: 'Light' },
+				{ value: 'dark', title: 'Dark' },
+				{ value: 'high-contrast', title: 'High Contrast' },
+			],
+			dynamicTitle: true,
+		},
+	},
+};
+
+function applyTheme(theme) {
+	if (!themeStyleEl) {
+		themeStyleEl = document.createElement('style');
+		themeStyleEl.id = 'uui-theme';
+		document.head.appendChild(themeStyleEl);
+	}
+	themeStyleEl.textContent = themes[theme] ?? lightCss;
+}
+
 class UmbStoryBookAuthContext extends UmbContextBase {
 	#isAuthorized = new UmbBooleanState(true);
 	isAuthorized = this.#isAuthorized.asObservable();
@@ -163,10 +198,15 @@ class UmbStoryBookElement extends UmbLitElement {
 
 customElements.define('umb-storybook', UmbStoryBookElement);
 
+
+const themeProvider = (story, context) => {
+	applyTheme(context.globals['theme'] ?? 'light');
+	return story();
+};
 const storybookProvider = (story) => html` <umb-storybook>${story()}</umb-storybook> `;
 
 // Provide the MSW addon decorator globally
-export const decorators = [storybookProvider];
+export const decorators = [themeProvider, storybookProvider];
 
 export const parameters = {
 	docs: {
@@ -190,25 +230,25 @@ export const parameters = {
 		},
 	},
 	backgrounds: {
-        options: {
-            greyish: {
+		options: {
+			greyish: {
 				name: 'Greyish',
 				value: '#F3F3F5',
 			},
 
-            white: {
+			white: {
 				name: 'White',
 				value: '#ffffff',
 			}
-        }
-    },
+		}
+	},
 };
 
 setCustomElements(customElementManifests);
 export const tags = ['autodocs'];
 
 export const initialGlobals = {
-    backgrounds: {
-        value: 'greyish'
-    }
+	backgrounds: {
+		value: 'greyish'
+	}
 };
diff --git a/src/Umbraco.Web.UI.Client/CLAUDE.md b/src/Umbraco.Web.UI.Client/CLAUDE.md
index 4a5865605812..a41c1d5d50ce 100644
--- a/src/Umbraco.Web.UI.Client/CLAUDE.md
+++ b/src/Umbraco.Web.UI.Client/CLAUDE.md
@@ -1,23 +1,17 @@
 # Umbraco Backoffice - @umbraco-cms/backoffice
 
-Modern TypeScript/Lit-based web components library for the Umbraco CMS backoffice interface. This project provides extensible UI components, APIs, and utilities for building the Umbraco CMS administration interface.
-
-**Package**: `@umbraco-cms/backoffice`
-**Version**: 17.1.0-rc
-**License**: MIT
-**Repository**: https://github.com/umbraco/Umbraco-CMS
-**Live Preview**: https://backofficepreview.umbraco.com/
-
----
+TypeScript/Lit web components library for the Umbraco CMS backoffice. Published as `@umbraco-cms/backoffice` (npm). Sub-project of the Umbraco CMS monorepo — for Git workflow, PR process, and CI/CD, see [repository root CLAUDE.md](../../CLAUDE.md).
 
 ## Documentation Structure
 
-This project's documentation is organized into 9 focused guides:
-
-**Note**: This is a sub-project in the Umbraco CMS monorepo. For Git workflow, PR process, and CI/CD information, see the [repository root CLAUDE.md](../../CLAUDE.md).
-
 ### Architecture & Design
-- **[Architecture](./docs/architecture.md)** - Technology stack, design patterns, module organization
+- **[Architecture](./docs/architecture.md)** - Technology stack, design philosophy, developer roles, package system, import map pipeline, design patterns
+- **[Entities](./docs/entities.md)** - Entity types, entity context, how entityType connects workspaces/trees/actions/routing
+- **[Workspaces](./docs/workspaces.md)** - Workspace types, base classes, extension points, workspace contexts, save flow, routing
+- **[Core Primitives](./docs/core-primitives.md)** - UmbLitElement, observable state (UmbArrayState, UmbObjectState, etc.), Context API, controller lifecycle
+- **[Data Flow](./docs/data-flow.md)** - Data flow chain, data sources, tryExecute, generated API clients, stores, complete worked example
+- **[Repositories](./docs/repositories.md)** - Repository categories (detail, item, tree, collection, action-specific), file structure, naming, extension registration, data source delegation
+- **[Package Development](./docs/package-development.md)** - Package & module structure, folder structure conventions, localization, organizational rules
 
 ### Development
 - **[Commands](./docs/commands.md)** - Build, test, and development commands
@@ -25,7 +19,8 @@ This project's documentation is organized into 9 focused guides:
 ### Code Quality
 - **[Style Guide](./docs/style-guide.md)** - Naming and formatting conventions
 - **[Clean Code](./docs/clean-code.md)** - Best practices and SOLID principles
-- **[Testing](./docs/testing.md)** - Unit, integration, and E2E testing strategies
+- **[Deprecation](./docs/deprecation.md)** - Breaking changes policy, deprecation patterns (JSDoc + UmbDeprecation)
+- **[Testing](./docs/testing.md)** - Testing strategy, priority by code area, MSW mocking, test patterns
 
 ### Troubleshooting
 - **[Error Handling](./docs/error-handling.md)** - Error patterns and debugging
@@ -37,29 +32,25 @@ This project's documentation is organized into 9 focused guides:
 
 ---
 
-## Quick Start
-
-### Prerequisites
+## Skills & Documentation — Mandatory Usage
 
-- **Node.js**: >=22.17.1
-- **npm**: >=10.9.2
-- Modern browser (Chrome, Firefox, Safari)
+**When a skill or documentation file exists for the task you are performing, you MUST use it. Do NOT improvise, skip steps, or manually create files that a skill is designed to scaffold.**
 
-### Initial Setup
+- Before starting any scaffolding or creation task, check if a matching skill exists in `.claude/skills/`. If one exists, invoke it.
+- Skills define prerequisites. If a prerequisite is not met, you MUST resolve it first using the appropriate skill.
+- Documentation files (`docs/*.md`) describe conventions and patterns. When they cover the area you are working in, read and follow them.
+- If a skill includes verification steps, run them before proceeding to the next step.
+- If you are unsure whether a skill applies, check — the cost of checking is low, the cost of skipping is high.
 
-```bash
-# 1. Clone repository
-git clone https://github.com/umbraco/Umbraco-CMS.git
-cd Umbraco-CMS/src/Umbraco.Web.UI.Client
+---
 
-# 2. Install dependencies
-npm install
+## Quick Start
 
-# 3. Start development
-npm run dev
+```bash
+cd src/Umbraco.Web.UI.Client && npm install && npm run dev
 ```
 
-### Most Common Commands
+### Common Commands
 
 See **[Commands](./docs/commands.md)** for all available commands.
 
@@ -76,32 +67,17 @@ See **[Commands](./docs/commands.md)** for all available commands.
 
 ## Quick Reference
 
-| Category | Details |
-|----------|---------|
-| **Apps** | `src/apps/` - Application entry points (app, installer, upgrader) |
-| **Libraries** | `src/libs/` - Core APIs (element-api, context-api, controller-api) |
-| **Packages** | `src/packages/` - Feature packages; `src/packages/core/` for utilities |
-| **External** | `src/external/` - Dependency wrappers (lit, rxjs, luxon) |
-| **Mocks** | `src/mocks/` - MSW handlers and mock data |
+| Item | Details |
+|------|---------|
 | **Config** | `package.json`, `vite.config.ts`, `.env` (create `.env.local`) |
-| **Elements** | Custom elements use `umb-{feature}-{component}` pattern |
-
-### Getting Help
-
-**Documentation**: [UI API Docs](npm run generate:ui-api-docs) | [Storybook](npm run storybook) | [Official Docs](https://docs.umbraco.com/)
-**Community**: [Issues](https://github.com/umbraco/Umbraco-CMS/issues) | [Discussions](https://github.com/umbraco/Umbraco-CMS/discussions) | [Forum](https://our.umbraco.com/)
+| **Element naming** | `umb-{feature}-{component}` for core; package devs use own prefix |
+| **Directory structure** | See [Architecture](./docs/architecture.md#architecture-pattern) |
 
 ---
 
 ## npm Package Publishing
 
-### Overview
-
-The backoffice is published to npm as `@umbraco-cms/backoffice` with a plugin-first architecture. All dependencies are **peerDependencies** because:
-
-1. **Importmap provides runtime**: The actual code at runtime comes from importmap, not npm
-2. **Types are the primary need**: Plugin developers need types for development, but runtime is managed centrally
-3. **Version flexibility**: Allows plugins to use different versions of pre-release packages (e.g., `@hey-api/openapi-ts`)
+All dependencies are **peerDependencies** because importmap provides runtime code; npm provides types only. This gives plugins version flexibility (e.g., different pre-release versions).
 
 ### Dependency Hoisting & Version Ranges
 
@@ -147,7 +123,7 @@ Why: Normalizes to conventional semver format
   "peerDependencies": {
     "lit": "^3.3.1",
     "rxjs": "^7.8.2",
-    "@umbraco-ui/uui": "^1.17.0-rc.5",
+    "@umbraco-ui/uui": "^2.0.0-alpha.1",
     "monaco-editor": "^0.55.1",
     "@tiptap/core": "^3.16.0",
     "@hey-api/openapi-ts": ">=0.85.0 <1.0.0"
@@ -173,7 +149,3 @@ When using `@umbraco-cms/backoffice`:
 | `devops/publish/cleanse-pkg.js` | Script that runs during `npm pack` to hoist and convert versions |
 | `src/external/*` | Dependency wrapper packages |
 | `src/packages/core` | Contains `@hey-api/openapi-ts` and other utilities |
-
----
-
-**This project follows a modular package architecture with strict TypeScript, Lit web components, and an extensible manifest system. Each package is independent but follows consistent patterns. For extension development, use the Context API for dependency injection, controllers for logic, and manifests for registration.**
diff --git a/src/Umbraco.Web.UI.Client/devops/build/copy-to-cms.js b/src/Umbraco.Web.UI.Client/devops/build/copy-to-cms.js
index 49d908e16965..f9ecdf9fa304 100644
--- a/src/Umbraco.Web.UI.Client/devops/build/copy-to-cms.js
+++ b/src/Umbraco.Web.UI.Client/devops/build/copy-to-cms.js
@@ -9,7 +9,10 @@ console.log('--- Copying assets ---');
 cpSync('./src/assets', `${srcDir}/assets`, { recursive: true });
 console.log('--- Copying assets done ---');
 
-// Copy SRC CSS
+// Copy Umbraco-specific CSS (umb-css.css, etc.) into dist-cms/css/.
+// Note: UUI theme CSS (dark.css, high-contrast.css) is already in dist-cms/css/
+// at this point, copied there by src/external/uui/vite.config.ts during the workspace build.
+// Theme manifests referencing these files live in src/packages/core/themes/manifests.ts.
 console.log('--- Copying src CSS ---');
 cpSync('./src/css', `${srcDir}/css`, { recursive: true });
 console.log('--- Copying src CSS done ---');
diff --git a/src/Umbraco.Web.UI.Client/devops/example-runner/index.js b/src/Umbraco.Web.UI.Client/devops/example-runner/index.js
index 2dd960c19896..c4e7d1cde3eb 100644
--- a/src/Umbraco.Web.UI.Client/devops/example-runner/index.js
+++ b/src/Umbraco.Web.UI.Client/devops/example-runner/index.js
@@ -33,13 +33,16 @@ async function pickExampleUI(){
 		const selectedFolder = exampleFolderNames[parseInt(answer) - 1];
 		console.log(`You selected: ${selectedFolder}`);
 
+		// Close readline before starting the dev server so Ctrl+C can terminate the process.
+		rl.close();
+
 		process.env['VITE_EXAMPLE_PATH'] = `${exampleDirectory}/${selectedFolder}`;
 
 		// Start vite server:
 		try {
 			execSync('npm run dev', {stdio: 'inherit'});
 		} catch (error) {
-			// Nothing, cause this is most likely just the server begin stopped.
+			// Nothing, cause this is most likely just the server being stopped.
 			//console.log(error);
 		}
 	});
diff --git a/src/Umbraco.Web.UI.Client/docs/architecture.md b/src/Umbraco.Web.UI.Client/docs/architecture.md
index 1ba164a447fa..2715ff24f3fc 100644
--- a/src/Umbraco.Web.UI.Client/docs/architecture.md
+++ b/src/Umbraco.Web.UI.Client/docs/architecture.md
@@ -1,124 +1,204 @@
 # Architecture
-[← Umbraco Backoffice](../CLAUDE.md) | [← Monorepo Root](../../CLAUDE.md)
 
 ---
 
-
 ### Technology Stack
 
-- **Node.js**: >=22.17.1
-- **npm**: >=10.9.2
-- **Language**: TypeScript 5.9.3
-- **Module System**: ESM (ES Modules)
-- **Framework**: Lit (Web Components)
-- **Build Tool**: Vite 7.1.11
-- **Test Framework**: @web/test-runner with Playwright
-- **E2E Testing**: Playwright 1.55.1
-- **Code Quality**: ESLint 9.37.0, Prettier 3.6.2
-- **Mocking**: MSW (Mock Service Worker) 1.3.5
-- **Documentation**: Storybook 9.0.14, TypeDoc 0.28.13
+> Exact versions are in `package.json` (root and workspace packages). Only major versions that affect API usage are listed here.
+
+- **Runtime**: Node.js >=22, npm >=10 (see `engines` in `package.json`)
+- **Language**: TypeScript 5.x (strict mode, ESM — all imports must use `.js` extensions)
+- **Framework**: **Lit 3** — Web Components with reactive templates, decorators, and `html`/`css` tagged template literals
+- **UI Library**: **@umbraco-ui/uui 1.x** — 80+ Web Components (`<uui-button>`, `<uui-input>`, `<uui-box>`, etc.). Always prefer UUI components over native HTML or custom implementations.
+- **Rich Text**: **TipTap 3** — ProseMirror-based editor (see `src/packages/tiptap/`)
+- **Build**: Vite 7 (config in `vite.config.ts`)
+- **State**: RxJS 7 wrapped by UmbState classes — see [Core Primitives](./core-primitives.md)
+- **Context/DI**: DOM-event-based Context API — see [Core Primitives](./core-primitives.md)
+- **Testing**: @web/test-runner + Playwright, @open-wc/testing — see [Testing](./testing.md)
+- **Mocking**: MSW 2 — see [Testing](./testing.md)
+- **Code Quality**: ESLint 9 (flat config), Prettier
+- **Key Libraries**: Luxon 3, Monaco Editor (code editing), DOMPurify 3 (sanitization — see [Security](./security.md)), Marked (Markdown→HTML), SignalR (real-time server events)
 
 ### Application Type
 
-Single-page web application (SPA) packaged as an npm library called `@umbraco-cms/backoffice` for typings and built as a bundle, which is copied over to `src/Umbraco.Cms.StaticAssets/wwwroot/umbraco/backoffice` for the CMS. Provides:
-- Extensible Web Components for CMS backoffice UI
-- API libraries for extension development
-- TypeScript type definitions
-- Package manifest system for extensions
+SPA packaged as npm library (`@umbraco-cms/backoffice`) for typings and built as a bundle copied to `src/Umbraco.Cms.StaticAssets/wwwroot/umbraco/backoffice`. Provides extensible Web Components, API libraries, TypeScript types, and a manifest-based extension system.
 
 ### Architecture Pattern
 
-**Modular Package Architecture** with clear separation:
+**Modular Package Architecture**:
 
 ```
 src/
-├── apps/              # Application entry points
-│   ├── app/          # Main backoffice application
-│   ├── backoffice/   # Backoffice shell
-│   ├── installer/    # CMS installer interface
-│   ├── preview/      # Content preview
-│   └── upgrader/     # CMS upgrader interface
-│
-├── libs/              # Core API libraries (infrastructure)
-│   ├── class-api/             # Base class utilities
-│   ├── context-api/           # Context API for dependency injection
-│   ├── context-proxy/         # Context proxying utilities
-│   ├── controller-api/        # Controller lifecycle management
-│   ├── element-api/           # Element base classes & mixins
-│   ├── extension-api/         # Extension registration & loading
-│   ├── localization-api/      # Internationalization
-│   └── observable-api/        # Reactive state management
-│
-├── packages/          # Feature packages (50+ packages)
-│   ├── core/         # Core utilities (auth, http, router, etc.)
-│   ├── content/      # Content management
+├── apps/              # Entry points (app, backoffice, installer, preview, upgrader)
+├── libs/              # Core API libraries (context-api, controller-api, element-api, extension-api, observable-api, localization-api, etc.)
+├── packages/          # Feature packages (50+)
+│   ├── core/         # UI framework (auth, http, router, modals, notifications, etc.)
 │   ├── documents/    # Document types & editing
 │   ├── media/        # Media management
-│   ├── members/      # Member management
-│   ├── user/         # User management
-│   ├── templating/   # Templates, scripts, stylesheets
-│   ├── block/        # Block editor components
-│   └── ...           # 30+ more specialized packages
-│
-├── external/          # External dependency wrappers
-│   ├── lit/          # Lit framework wrapper
-│   ├── rxjs/         # RxJS wrapper
-│   ├── luxon/        # Date/time library wrapper
-│   ├── monaco-editor/# Code editor wrapper
-│   └── ...           # Other wrapped dependencies
-│
+│   └── ...           # 30+ more domain packages
+├── external/          # Dependency wrappers (lit, rxjs, luxon, monaco-editor, etc.)
 ├── mocks/             # MSW mock handlers & test data
-│   ├── data/         # Mock database
-│   └── handlers/     # API request handlers
-│
 └── assets/            # Static assets (fonts, images, localization)
 ```
 
-### Design Patterns
+---
+
+## Design Philosophy
+
+**Extension-first architecture**: HQ builds extensions the same way third-party developers do. All UI (sections, dashboards, property editors, workspaces, trees, actions) is registered via manifests. Any default behavior can be replaced, overridden, or removed. Consumers can use any framework that outputs a Web Component.
+
+*Note: The extension-first mindset is the guiding principle, and the frontend fully embraces this by treating all features as manifest-registered, replaceable extensions.*
+
+---
+
+## Developer Roles & Import Boundaries
+
+The directory a file lives in determines which import rules apply:
+
+| Role | Directory | Can import from | Cannot import from |
+|------|-----------|----------------|--------------------|
+| Library Developer | `src/libs/` | Other libs | Packages, apps |
+| Core Developer | `src/packages/core/` | Libs, other core modules | Non-core packages |
+| HQ Package Developer | `src/packages/*` (not core) | Core, libs, other packages (carefully) | — |
+
+**Library Developer** (`src/libs/`): Framework-agnostic infrastructure. No knowledge of the backoffice, CMS, or UI framework. Third-party dependencies included carefully.
+
+**Core Developer** (`src/packages/core/`): UI framework implementation — extension registry, routing, modals, notifications, workspace infrastructure. Does not implement CMS-specific features.
+
+**HQ Package Developer** (`src/packages/*` except `core/`): CMS feature packages (documents, media, members, templating). Cross-package imports increase coupling — minimize them. Use public `index.ts` exports, never import another package's internal files.
+
+---
+
+## The Package System
+
+Each directory under `src/packages/` is a self-contained domain module. Design principle: each package could theoretically be uninstalled independently. `core` provides foundational APIs; every other package builds on top.
+
+### Module Exports
+
+Packages expose subpath exports (e.g., `@umbraco-cms/backoffice/dashboard`, `@umbraco-cms/backoffice/media`). Each maps to an `index.ts` barrel file. See `package.json` exports field for the full list.
+
+---
+
+## Design Patterns
 
-1. **Web Components** - Custom elements with Shadow DOM encapsulation
-2. **Context API** - Dependency injection via context providers/consumers (similar to React Context)
-3. **Controller Pattern** - Lifecycle-aware controllers for managing component behavior
+1. **Web Components** - Custom elements with Shadow DOM
+2. **Context API** - DOM-event-based dependency injection (provider/consumer)
+3. **Controller Pattern** - Lifecycle-aware logic via `UmbControllerBase`
 4. **Extension System** - Manifest-based plugin architecture
-5. **Observable Pattern** - Reactive state management with RxJS observables
-6. **Repository Pattern** - Data access abstraction via repository classes
-7. **Mixin Pattern** - Composable behaviors via TypeScript mixins (`UmbElementMixin`, etc.)
-8. **Builder Pattern** - For complex object construction
-9. **Registry Pattern** - Extension registry for dynamic feature loading
-10. **Observer Pattern** - Event-driven communication between components
-
-### Key Technologies
-
-**Core Framework**:
-- Lit 3.x - Web Components framework with reactive templates
-- TypeScript 5.9 - Type-safe development with strict mode
-- Vite - Fast build tool and dev server
-
-**UI Components**:
-- @umbraco-ui/uui - Umbraco UI component library
-- Shadow DOM - Component style encapsulation
-- Custom Elements API - Native web components
-
-**State & Data**:
-- RxJS - Reactive programming with observables
-- Context API - State management & dependency injection
-- MSW - API mocking for development & testing
-
-**Testing**:
-- @web/test-runner - Fast test runner for web components
-- Playwright - E2E browser testing
-- @open-wc/testing - Testing utilities for web components
-
-**Code Quality**:
-- ESLint with TypeScript plugin - Linting with strict rules
-- Prettier - Code formatting
-- TypeDoc - API documentation generation
-- Web Component Analyzer - Custom element documentation
-
-**Other**:
-- Luxon - Date/time manipulation
-- Monaco Editor - Code editing
-- DOMPurify - HTML sanitization
-- Marked - Markdown parsing
-- SignalR - Real-time communication
+5. **Observable Pattern** - Reactive state via UmbState classes
+6. **Repository Pattern** - Data access abstraction
+7. **Mixin Pattern** - Composable behaviors (`UmbElementMixin`, etc.)
+
+### Extension Registry
+
+All UI is registered as **Extension Manifests**. The registry is mutable at runtime — extensions can be added, removed, or replaced.
+
+```typescript
+const manifest: UmbExtensionManifest = {
+  type: 'dashboard',
+  alias: 'My.Dashboard',
+  name: 'My Dashboard',
+  element: () => import('./my-dashboard.element.js'),
+  weight: 100,
+  meta: { label: 'My Dashboard', pathname: 'my-dashboard' },
+  conditions: [
+    { alias: 'Umb.Condition.SectionAlias', match: 'Umb.Section.Content' },
+  ],
+};
+```
+
+Key extension types: `section`, `sectionView`, `dashboard`, `workspace`, `workspaceView`, `workspaceAction`, `workspaceContext`, `propertyEditorUi`, `propertyEditorSchema`, `tree`, `treeItem`, `menuItem`, `entityAction`, `entityBulkAction`, `headerApp`, `globalContext`, `modal`, `bundle`, `backofficeEntryPoint`, `localization`, `condition`, `kind`.
+
+**Registration methods:**
+
+- **Internal packages**: `umbraco-package.ts` exports a `bundle` manifest with `js: () => import('./manifests.js')`. The `manifests.ts` aggregates sub-feature manifests. Bundle type ensures lazy-loading.
+
+```typescript
+// umbraco-package.ts
+export const name = 'Umbraco.Core.MyPackage';
+export const extensions = [
+  { name: 'My Package Bundle', alias: 'Umb.Bundle.MyPackage', type: 'bundle', js: () => import('./manifests.js') },
+];
+
+// manifests.ts
+import { manifests as featureAManifests } from './feature-a/manifests.js';
+export const manifests: Array<UmbExtensionManifest | UmbExtensionManifestKind> = [...featureAManifests];
+```
+
+- **External packages**: `umbraco-package.json` (static).
+- **Runtime**: `umbExtensionsRegistry.register(manifest)` or `registerMany(manifests)`.
+
+**Conditions**: Declarative rules for when an extension is active (e.g., section alias match, user permission).
+
+### Kinds
+
+Kinds are **generic, reusable implementations of an extension type**. A kind provides a pre-built `element`, `api`, or both for a specific purpose. Extensions reference a kind to inherit its implementation, then customize behavior through `meta`.
+
+**How it works**: The registry merges kind defaults with the extension manifest. Extension properties override kind properties; `meta` is shallow-merged (extension meta extends/overrides kind meta).
+
+**Defining a kind** (in a `*.kind.ts` file):
+
+```typescript
+export const manifest: UmbExtensionManifestKind = {
+  type: 'kind',
+  alias: 'Umb.Kind.EntityAction.Delete',
+  matchKind: 'delete',
+  matchType: 'entityAction',
+  manifest: {
+    type: 'entityAction',
+    kind: 'delete',
+    api: () => import('./delete.action.js'),
+    meta: {
+      icon: 'icon-trash',
+      label: '#actions_delete',
+      itemRepositoryAlias: '',       // to be filled by each integration
+      detailRepositoryAlias: '',
+    },
+  },
+};
+```
+
+**Using a kind** — the extension only specifies what differs:
+
+```typescript
+{
+  type: 'entityAction',
+  kind: 'delete',                    // inherits element, api, icon, label from the kind
+  alias: 'Umb.EntityAction.DocumentType.Delete',
+  name: 'Delete Document-Type Entity Action',
+  forEntityTypes: [UMB_DOCUMENT_TYPE_ENTITY_TYPE],
+  meta: {                            // customize via meta
+    itemRepositoryAlias: UMB_DOCUMENT_TYPE_ITEM_REPOSITORY_ALIAS,
+    detailRepositoryAlias: UMB_DOCUMENT_TYPE_DETAIL_REPOSITORY_ALIAS,
+  },
+}
+```
+
+**Best practices:**
+- Kinds are for reusability — use them when multiple extensions share the same element/api implementation with only meta differences.
+- Any package (core or feature) can register kinds. Core provides common kinds (delete, moveTo, duplicate, default section, default workspace, etc.); feature packages can define domain-specific kinds.
+- Individual integrations customize behavior through `meta` — not by overriding `element` or `api` (unless replacing the implementation entirely).
+- Kinds can extend other kinds by spreading their manifest: `manifest: { ...UMB_ENTITY_ACTION_DEFAULT_KIND_MANIFEST.manifest, kind: 'delete', ... }`.
+- **Changing a kind affects all extensions that use it.** Treat kind implementations (element, api, meta shape) as a shared contract — changes have a wide blast radius across packages.
+
+### Context API, Observable State & Controllers
+
+These core primitives are documented in detail in **[Core Primitives](./core-primitives.md)**. In brief:
+
+- **Context API** — DOM-event-based dependency injection. Providers expose typed contexts to descendant elements via `provideContext()`, consumers access them via `consumeContext()` or `getContext()`.
+- **Observable State** — Reactive state containers (`UmbStringState`, `UmbArrayState`, `UmbObjectState`, etc.). Elements subscribe via `this.observe()` which handles lifecycle automatically.
+- **Controllers** — `UmbControllerBase` for logic not tied to rendering. Attach to a host element and participate in its lifecycle.
+
+**Important**: Avoid using RxJS operators (`map`, `filter`, `combineLatest`, `switchMap`) directly. Use UmbState classes and `observe()` — they handle subscription lifecycle automatically. RxJS is an implementation detail.
+
+### Repository Pattern & Data Flow
+
+No element or context should call the Management API directly. All data flows through repositories:
+
+`Element` → observes → `Context` → calls → `Repository` → delegates to → `Data Source` → calls → `Generated API Client`
+
+See **[Data Flow](./data-flow.md)** for the complete implementation pattern with base classes, `tryExecute()`, and a worked example.
+
+---
 
+The backoffice is independently-packaged Web Components glued by the Extension Registry, communicating via the Context API, with state managed through Observables — all built to be replaceable and extensible by default.
diff --git a/src/Umbraco.Web.UI.Client/docs/clean-code.md b/src/Umbraco.Web.UI.Client/docs/clean-code.md
index 4c4a36764c89..1c879d22be3b 100644
--- a/src/Umbraco.Web.UI.Client/docs/clean-code.md
+++ b/src/Umbraco.Web.UI.Client/docs/clean-code.md
@@ -462,6 +462,23 @@ export class UmbDocumentActionButton extends LitElement {
 - Remove unused imports, functions, variables
 - Clean up console.logs before committing
 
+### Feature Parity with Core Equivalents
+
+When implementing a new component that mirrors an existing core or sibling implementation (e.g. a new collection action alongside document/media/member equivalents), do a side-by-side comparison against the core version before considering it done.
+
+**Checklist**:
+
+1. **Full API surface**: Read the reference implementation's controller/API usage line by line. Every method call, callback, and property access on controllers in the reference must have a counterpart in the new implementation — don't cherry-pick only the obvious ones.
+2. **Error handling**: Match the core's error handling pattern (e.g. `.catch(() => {})` on `execute()` calls) to prevent unhandled promise rejections.
+3. **Type hierarchy**: Before defining new interfaces, search for existing base types (e.g. `UmbNamedEntityModel` vs `UmbEntityModel`) that already declare the fields you need. Use the most specific base.
+4. **UI consistency**: Check CSS from sibling implementations (e.g. `max-height` on scroll containers, icon fallbacks like `?? 'icon-document'`).
+5. **Context-appropriate strings**: Don't reuse localization keys from another domain (e.g. `create_noDocumentTypes` in an elements context). Either create a new key or use only the inline fallback text.
+
+**Core components to compare against** (common patterns):
+- Collection create actions: `src/packages/core/collection/action/create/collection-create-action.element.ts`
+- Entity create option modals: `src/packages/core/entity-action/common/create/modal/entity-create-option-action-list-modal.element.ts`
+- Document/media/member equivalents in their respective `src/packages/` directories
+
 ### Patterns to Avoid
 
 **Don't**:
diff --git a/src/Umbraco.Web.UI.Client/docs/core-primitives.md b/src/Umbraco.Web.UI.Client/docs/core-primitives.md
new file mode 100644
index 000000000000..6d24c9d0e305
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/docs/core-primitives.md
@@ -0,0 +1,362 @@
+# Core Primitives
+
+The foundational building blocks that all backoffice code is built on. These live in `src/libs/` and are framework-agnostic (no CMS domain knowledge).
+
+---
+
+## UmbLitElement
+
+**The base class for all web components in the backoffice.** Never extend `LitElement` directly.
+
+```typescript
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+
+@customElement('umb-my-element')
+export class UmbMyElement extends UmbLitElement {
+	// All primitives below are available on `this`
+}
+```
+
+UmbLitElement extends Lit's `LitElement` with four core capabilities:
+
+### observe(source, callback?, controllerAlias?)
+
+Lifecycle-managed observable subscription. Automatically unsubscribes when the element disconnects from the DOM — no manual cleanup needed.
+
+```typescript
+// Basic usage — subscribe to an observable, update @state
+this.observe(context.items, (items) => {
+	this._items = items;
+});
+
+// With explicit alias — allows replacement or removal by name
+this.observe(context.items, (items) => {
+	this._items = items;
+}, '_observeItems');
+
+// Later, stop observing by alias:
+this.removeUmbControllerByAlias('_observeItems');
+
+// Combining multiple observables (emits when ANY source changes)
+import { observeMultiple } from '@umbraco-cms/backoffice/observable-api';
+
+this.observe(
+	observeMultiple([context.items, context.filter]),
+	([items, filter]) => {
+		this._items = items;
+		this._filter = filter;
+	},
+	'_observeItemsAndFilter',
+);
+```
+
+**Alias behavior:**
+- If omitted and callback exists: auto-generated hash of the callback function
+- If `null`: no alias (controller cannot be replaced by alias)
+- If provided: explicit string/symbol for later reference
+
+### consumeContext(alias, callback)
+
+Subscribe to a context provided by an ancestor element. The callback fires when the context becomes available (and re-fires if the context changes).
+
+```typescript
+#myContext?: typeof UMB_MY_CONTEXT.TYPE;
+
+constructor() {
+	super();
+	this.consumeContext(UMB_MY_CONTEXT, (context) => {
+		this.#myContext = context;
+		// Set up observations on the context here
+		this.observe(context.items, (items) => {
+			this._items = items;
+		});
+	});
+}
+```
+
+### getContext(alias, options?)
+
+Promise-based one-time context retrieval. Use for user-triggered actions where you don't need continuous observation.
+
+```typescript
+async #handleClick() {
+	const notificationContext = await this.getContext(UMB_NOTIFICATION_CONTEXT);
+	notificationContext?.peek('positive', { data: { message: 'Done!' } });
+}
+```
+
+### provideContext(alias, instance)
+
+Make a context instance available to all descendant elements.
+
+```typescript
+constructor() {
+	super();
+	this.provideContext(UMB_MY_CONTEXT, new UmbMyContext(this));
+}
+```
+
+### this.localize
+
+Built-in localization controller. Available on every UmbLitElement.
+
+```typescript
+// In templates
+html`<span>${this.localize.term('general_close')}</span>`
+
+// In code
+const label = this.localize.term('content_createBlueprintFrom');
+```
+
+---
+
+## Observable State
+
+Reactive state containers built on RxJS `BehaviorSubject`. All state classes emit the current value immediately on subscription, then emit on every change.
+
+### State Types
+
+| Class | For | Change Detection |
+|-------|-----|-----------------|
+| `UmbStringState` | Strings | `!==` (reference) |
+| `UmbNumberState` | Numbers | `!==` (reference) |
+| `UmbBooleanState` | Booleans | `!==` (reference) |
+| `UmbObjectState` | Objects | JSON deep comparison + deep freeze |
+| `UmbArrayState` | Arrays | JSON deep comparison + deep freeze |
+| `UmbClassState` | Class instances | `.equal()` method on the class |
+| `UmbDeepState` | Any (base for Object/Array) | JSON deep comparison + deep freeze |
+
+### Basic Usage
+
+```typescript
+import { UmbStringState, UmbArrayState, UmbObjectState } from '@umbraco-cms/backoffice/observable-api';
+
+// Create state (private)
+#name = new UmbStringState('');
+#items = new UmbArrayState<MyItem>([], (item) => item.unique);
+#data = new UmbObjectState<MyModel | undefined>(undefined);
+
+// Expose as observable (public, read-only)
+readonly name = this.#name.asObservable();
+readonly items = this.#items.asObservable();
+readonly data = this.#data.asObservable();
+
+// Read current value
+const currentName = this.#name.getValue();
+
+// Update value
+this.#name.setValue('new name');
+```
+
+### UmbArrayState
+
+Requires a unique-key function for identity tracking. Provides rich array manipulation methods.
+
+```typescript
+#items = new UmbArrayState<MyItem>([], (item) => item.unique);
+
+// Append
+this.#items.appendOne(newItem);
+this.#items.append([item1, item2]);
+
+// Remove
+this.#items.removeOne('unique-id');
+this.#items.remove(['id1', 'id2']);
+
+// Update a single item (partial merge)
+this.#items.updateOne('unique-id', { name: 'Updated' });
+
+// Filter
+this.#items.filter((item) => item.active);
+
+// Sort
+this.#items.sortBy((a, b) => a.name.localeCompare(b.name));
+
+// Clear
+this.#items.clear();
+
+// Check existence
+this.#items.getHasOne('unique-id'); // boolean
+```
+
+### UmbObjectState
+
+```typescript
+#data = new UmbObjectState<MyModel>({ name: '', count: 0 });
+
+// Partial update (shallow merge)
+this.#data.update({ name: 'Updated' }); // count stays 0
+```
+
+### Derived Observables (asObservablePart)
+
+Create an observable that only emits when a specific derived value changes. Uses memoization to avoid unnecessary updates.
+
+```typescript
+// Only emits when the name changes, not when other properties change
+readonly name = this.#data.asObservablePart((data) => data?.name);
+
+// Count of items
+readonly itemCount = this.#items.asObservablePart((items) => items.length);
+
+// First item
+readonly firstItem = this.#items.asObservablePart((items) => items[0]);
+```
+
+### Deep Freeze
+
+`UmbDeepState`, `UmbObjectState`, and `UmbArrayState` deep-freeze their data. Attempting to mutate frozen data throws an error in development. This enforces immutable update patterns:
+
+```typescript
+// WRONG — throws TypeError in development
+const items = this.#items.getValue();
+items.push(newItem); // Frozen!
+
+// CORRECT — create new array
+this.#items.appendOne(newItem);
+// or
+this.#items.setValue([...this.#items.getValue(), newItem]);
+```
+
+### Mute/Unmute
+
+`UmbDeepState` (and its subclasses) support muting to batch multiple updates without emitting intermediate values:
+
+```typescript
+this.#data.mute();
+this.#data.update({ name: 'a' });
+this.#data.update({ count: 1 });
+this.#data.unmute(); // Single emission with both changes
+```
+
+---
+
+## Context API
+
+Framework-agnostic dependency injection via DOM events. Contexts flow **down** the DOM tree from provider to consumer.
+
+### UmbContextToken
+
+Type-safe identifier for a context. The generic parameters flow through to `consumeContext()` and `getContext()` return types.
+
+```typescript
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+
+// Simple token
+export const UMB_MY_CONTEXT = new UmbContextToken<UmbMyContext>('UmbMyContext');
+
+// Token with discriminator (for type narrowing)
+export const UMB_MY_SPECIFIC_CONTEXT = new UmbContextToken<UmbMyBaseContext, UmbMySpecificContext>(
+	'UmbMyContext',          // contextAlias — matches the provider alias
+	'UmbMySpecificContext',  // apiAlias — distinguishes variant
+	(context): context is UmbMySpecificContext => context instanceof UmbMySpecificContext,
+);
+```
+
+**The `.TYPE` property** gives you the resolved type for variable declarations:
+
+```typescript
+#myContext?: typeof UMB_MY_CONTEXT.TYPE;
+```
+
+### How It Works
+
+1. **Provider** registers a context instance on a host element
+2. **Consumer** dispatches a DOM event that bubbles up the tree
+3. When the event reaches a provider with a matching alias, the provider calls back with the instance
+4. The consumer's callback fires with the typed context
+
+### Creating a Context
+
+```typescript
+import { UmbContextBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+
+export const UMB_MY_CONTEXT = new UmbContextToken<UmbMyContext>('UmbMyContext');
+
+export class UmbMyContext extends UmbContextBase<UmbMyContext> {
+	// State, observables, methods...
+
+	constructor(host: UmbControllerHost) {
+		super(host, UMB_MY_CONTEXT);
+	}
+}
+```
+
+`UmbContextBase` automatically calls `provideContext()` in its constructor, making the context available to descendants.
+
+### Common Built-in Contexts
+
+```typescript
+import { UMB_NOTIFICATION_CONTEXT } from '@umbraco-cms/backoffice/notification';
+import { UMB_MODAL_MANAGER_CONTEXT } from '@umbraco-cms/backoffice/modal';
+import { UMB_AUTH_CONTEXT } from '@umbraco-cms/backoffice/auth';
+import { UMB_CURRENT_USER_CONTEXT } from '@umbraco-cms/backoffice/current-user';
+```
+
+---
+
+## Controller Pattern
+
+Lifecycle-aware logic units that attach to a host (element or other controller). Controllers implement `UmbController` and are managed by the host's controller system.
+
+### UmbControllerBase
+
+Base class for non-element controllers. Has the same `observe()`, `consumeContext()`, `provideContext()`, and `getContext()` methods as `UmbLitElement`.
+
+```typescript
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+
+export class UmbMyController extends UmbControllerBase {
+	constructor(host: UmbControllerHost) {
+		super(host, 'my-controller-alias'); // alias is optional
+	}
+
+	// Has full access to observe(), consumeContext(), etc.
+}
+```
+
+### Controller Lifecycle
+
+```
+host.addUmbController(ctrl)  →  ctrl.hostConnected()
+                                       ↓
+                              (subscriptions active, DOM events listening)
+                                       ↓
+host disconnects from DOM     →  ctrl.hostDisconnected()
+                                       ↓
+                              (subscriptions paused)
+                                       ↓
+host reconnects to DOM        →  ctrl.hostConnected()
+                                       ↓
+host.removeUmbController(ctrl) → ctrl.destroy()
+```
+
+### Controller Aliases
+
+When a controller is added with an alias that already exists on the host, the **old controller is destroyed and replaced**. This is how `observe()` avoids duplicate subscriptions when called multiple times:
+
+```typescript
+// First call: creates observer with alias '_observeItems'
+this.observe(context.items, (items) => { ... }, '_observeItems');
+
+// Second call: destroys previous '_observeItems' observer, creates new one
+this.observe(context.items, (items) => { ... }, '_observeItems');
+```
+
+---
+
+## Quick Reference
+
+| Primitive | Import Path | Purpose |
+|-----------|-------------|---------|
+| `UmbLitElement` | `@umbraco-cms/backoffice/lit-element` | Base class for all elements |
+| `UmbControllerBase` | `@umbraco-cms/backoffice/class-api` | Base class for non-element controllers |
+| `UmbContextBase` | `@umbraco-cms/backoffice/class-api` | Base class for contexts (auto-provides) |
+| `UmbContextToken` | `@umbraco-cms/backoffice/context-api` | Type-safe context identifier |
+| `UmbStringState` | `@umbraco-cms/backoffice/observable-api` | String state container |
+| `UmbNumberState` | `@umbraco-cms/backoffice/observable-api` | Number state container |
+| `UmbBooleanState` | `@umbraco-cms/backoffice/observable-api` | Boolean state container |
+| `UmbArrayState` | `@umbraco-cms/backoffice/observable-api` | Array state container (requires unique key) |
+| `UmbObjectState` | `@umbraco-cms/backoffice/observable-api` | Object state container |
+| `observeMultiple` | `@umbraco-cms/backoffice/observable-api` | Combine multiple observables |
diff --git a/src/Umbraco.Web.UI.Client/docs/data-flow.md b/src/Umbraco.Web.UI.Client/docs/data-flow.md
new file mode 100644
index 000000000000..7908da0517ea
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/docs/data-flow.md
@@ -0,0 +1,413 @@
+# Data Flow & API Integration
+
+How data moves between the server and UI components. This covers the internal implementation pattern using base classes — the same pattern used across all entity types in the backoffice. For how repositories are categorized, organized, and structured across features, see [Repositories](./repositories.md).
+
+---
+
+## The Data Flow Chain
+
+```
+Element ──observe()──> Workspace Context ──> Repository ──> Data Source ──> Generated API Client ──> Server
+   ↑                        ↑                    ↑
+   └── @state updates ──────┘                    │
+                                                 ↓
+                                              Store (cache)
+```
+
+Each layer has a single responsibility:
+
+| Layer | Responsibility |
+|-------|---------------|
+| **Element** | Renders UI, handles user input |
+| **Context** | Coordinates data and lifecycle for a feature |
+| **Repository** | Orchestrates data source + store |
+| **Data Source** | Maps between server API and domain models |
+| **Store** | Caches entities, provides observables (see note below) |
+| **Generated Client** | Typed HTTP calls from OpenAPI spec |
+
+Each layer has domain-specific base classes depending on the type of data operation (detail CRUD, item listing, collection, tree, etc.). See [Repositories](./repositories.md) for a complete guide to all repository categories and when to use each. The example below uses the **detail** variant.
+
+### Store Direction
+
+Stores are being phased out. Only **Detail Store** and **Item Store** remain in active use. Do not introduce new store types. New features should manage state within the context/workspace layer instead, using observable state classes directly. The existing detail and item stores will be addressed in a future version.
+
+---
+
+## Generated API Client
+
+API clients are auto-generated from the backend OpenAPI specification.
+
+### Generation
+
+```bash
+npm run generate:server-api
+```
+
+This reads `src/packages/core/openapi-ts.config.ts` and outputs typed service classes and models to `src/packages/core/backend-api/`.
+
+### Usage
+
+Generated services are imported from the `external/backend-api` subpath:
+
+```typescript
+import { WebhookService } from '@umbraco-cms/backoffice/external/backend-api';
+import type { CreateWebhookRequestModel } from '@umbraco-cms/backoffice/external/backend-api';
+```
+
+**Never call generated services directly from elements or contexts.** Always go through a data source and repository.
+
+---
+
+## Caching & Request Deduplication
+
+Caching and request deduplication live **between the data source and the API client** — not in the repository or context. This is the layer that knows the API transport details needed to deduplicate and cache effectively.
+
+```
+Data Source ──> Request Manager ──> Generated API Client
+                   ├─ Data cache: returns cached items immediately
+                   ├─ Inflight cache: deduplicates concurrent requests for the same data
+                   └─ Server event sync: invalidates cache when the server broadcasts changes
+```
+
+The `management-api` package provides base classes for this: `UmbManagementApiItemDataRequestManager` handles the caching/deduplication logic, and concrete implementations wire it to a specific API endpoint and cache instance. See the document, media, and member item data sources for examples.
+
+This pattern is specific to the Management API transport. Other data sources (e.g., a custom API or offline source) would implement their own caching strategy in the same position — between data source and transport.
+
+---
+
+## tryExecute
+
+The standard wrapper for all API calls. Handles errors, shows notifications, and returns a `{ data, error }` tuple — never throws.
+
+```typescript
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+
+const { data, error } = await tryExecute(
+	this.#host,
+	WebhookService.getWebhookById({ path: { id: unique } }),
+);
+
+if (error || !data) {
+	return { error };
+}
+```
+
+**Parameters:**
+- `host` — Controller host (for notification context access)
+- `promise` — The API call promise
+- `opts?` — Optional: `{ abortSignal?, disableNotifications? }`
+
+**Behavior:**
+- Returns `{ data }` on success
+- Returns `{ error }` on failure (never throws)
+- Automatically shows error notifications to the user
+- Silently handles 401/403/404 (UI is expected to handle these)
+
+---
+
+## Detail Data Flow Example
+
+A generic example showing the structural pattern for each layer. Replace `MyEntity` with the actual entity name. When implementing, find an existing entity in the codebase that is similar to your task and follow its patterns.
+
+### 1. Domain Model
+
+```typescript
+export interface UmbMyEntityDetailModel {
+	entityType: string;
+	unique: string;
+	name: string;
+	// ... domain-specific properties
+}
+```
+
+### 2. Data Source
+
+Implements the data source interface for the domain. Responsible for calling the generated API client and mapping between server types and the domain model.
+
+```typescript
+import type { UmbMyEntityDetailModel } from '../../types.js';
+import { UMB_MY_ENTITY_ENTITY_TYPE } from '../../entity.js';
+import { UmbId } from '@umbraco-cms/backoffice/id';
+import type { UmbDetailDataSource } from '@umbraco-cms/backoffice/repository';
+import { MyEntityService } from '@umbraco-cms/backoffice/external/backend-api';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+
+export class UmbMyEntityDetailServerDataSource implements UmbDetailDataSource<UmbMyEntityDetailModel> {
+	#host: UmbControllerHost;
+
+	constructor(host: UmbControllerHost) {
+		this.#host = host;
+	}
+
+	async createScaffold(preset: Partial<UmbMyEntityDetailModel> = {}) {
+		const data: UmbMyEntityDetailModel = {
+			entityType: UMB_MY_ENTITY_ENTITY_TYPE,
+			unique: UmbId.new(),
+			name: '',
+			// ... defaults for domain-specific properties
+			...preset,
+		};
+		return { data };
+	}
+
+	async read(unique: string) {
+		if (!unique) throw new Error('Unique is missing');
+
+		const { data, error } = await tryExecute(
+			this.#host,
+			MyEntityService.getMyEntityById({ path: { id: unique } }),
+		);
+
+		if (error || !data) {
+			return { error };
+		}
+
+		// Map: server response → domain model
+		const model: UmbMyEntityDetailModel = {
+			entityType: UMB_MY_ENTITY_ENTITY_TYPE,
+			unique: data.id,
+			name: data.name ?? '',
+			// ... map domain-specific properties
+		};
+
+		return { data: model };
+	}
+
+	async create(model: UmbMyEntityDetailModel) {
+		if (!model) throw new Error('Model is missing');
+
+		// Map: domain model → server request
+		const body = {
+			id: model.unique,
+			name: model.name,
+			// ... map domain-specific properties
+		};
+
+		const { data, error } = await tryExecute(
+			this.#host,
+			MyEntityService.postMyEntity({ body }),
+		);
+
+		if (data) {
+			return this.read(data as never);
+		}
+		return { error };
+	}
+
+	async update(model: UmbMyEntityDetailModel) {
+		if (!model.unique) throw new Error('Unique is missing');
+
+		const body = {
+			name: model.name,
+			// ... map domain-specific properties
+		};
+
+		const { error } = await tryExecute(
+			this.#host,
+			MyEntityService.putMyEntityById({ path: { id: model.unique }, body }),
+		);
+
+		if (!error) {
+			return this.read(model.unique);
+		}
+		return { error };
+	}
+
+	async delete(unique: string) {
+		if (!unique) throw new Error('Unique is missing');
+
+		return tryExecute(
+			this.#host,
+			MyEntityService.deleteMyEntityById({ path: { id: unique } }),
+		);
+	}
+}
+```
+
+**Key pattern:** The data source is the only layer that knows about server API types. It maps in both directions — server → domain on reads, domain → server on writes.
+
+### 3. Store
+
+```typescript
+import type { UmbMyEntityDetailModel } from '../../types.js';
+import { UmbContextToken } from '@umbraco-cms/backoffice/context-api';
+import { UmbDetailStoreBase } from '@umbraco-cms/backoffice/store';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+
+export class UmbMyEntityDetailStore extends UmbDetailStoreBase<UmbMyEntityDetailModel> {
+	constructor(host: UmbControllerHost) {
+		super(host, UMB_MY_ENTITY_DETAIL_STORE_CONTEXT.toString());
+	}
+}
+
+export const UMB_MY_ENTITY_DETAIL_STORE_CONTEXT = new UmbContextToken<UmbMyEntityDetailStore>(
+	'UmbMyEntityDetailStore',
+);
+```
+
+### 4. Repository
+
+Wires data source + store together. The base class handles all CRUD orchestration.
+
+```typescript
+import type { UmbMyEntityDetailModel } from '../../types.js';
+import { UmbMyEntityDetailServerDataSource } from './my-entity-detail.server.data-source.js';
+import { UMB_MY_ENTITY_DETAIL_STORE_CONTEXT } from './my-entity-detail.store.js';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbDetailRepositoryBase } from '@umbraco-cms/backoffice/repository';
+
+export class UmbMyEntityDetailRepository extends UmbDetailRepositoryBase<UmbMyEntityDetailModel> {
+	constructor(host: UmbControllerHost) {
+		super(host, UmbMyEntityDetailServerDataSource, UMB_MY_ENTITY_DETAIL_STORE_CONTEXT);
+	}
+}
+
+export { UmbMyEntityDetailRepository as api };
+```
+
+### 5. Workspace Context
+
+Manages entity lifecycle and exposes observable state for elements.
+
+```typescript
+import { UMB_MY_ENTITY_DETAIL_REPOSITORY_ALIAS } from '../repository/index.js';
+import { UMB_MY_ENTITY_ENTITY_TYPE, UMB_MY_ENTITY_WORKSPACE_ALIAS } from '../../entity.js';
+import type { UmbMyEntityDetailModel } from '../types.js';
+import { UmbEntityNamedDetailWorkspaceContextBase } from '@umbraco-cms/backoffice/workspace';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+
+export class UmbMyEntityWorkspaceContext
+	extends UmbEntityNamedDetailWorkspaceContextBase<UmbMyEntityDetailModel>
+{
+	// Derived observables — only emit when the specific property changes
+	readonly myProperty = this._data.createObservablePartOfCurrent((data) => data?.myProperty);
+
+	constructor(host: UmbControllerHost) {
+		super(host, {
+			workspaceAlias: UMB_MY_ENTITY_WORKSPACE_ALIAS,
+			entityType: UMB_MY_ENTITY_ENTITY_TYPE,
+			detailRepositoryAlias: UMB_MY_ENTITY_DETAIL_REPOSITORY_ALIAS,
+		});
+	}
+
+	// Setters mutate the current data — triggers observable updates
+	setMyProperty(value: string) {
+		this._data.updateCurrent({ myProperty: value });
+	}
+}
+
+export { UmbMyEntityWorkspaceContext as api };
+```
+
+### 6. Element
+
+Consumes context, observes data, renders UI, dispatches user actions back to context.
+
+```typescript
+import { UMB_MY_ENTITY_WORKSPACE_CONTEXT } from '../my-entity-workspace.context-token.js';
+import type { UmbMyEntityDetailModel } from '../../types.js';
+import { customElement, html, state, nothing } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+
+@customElement('umb-my-entity-workspace-view')
+export class UmbMyEntityWorkspaceViewElement extends UmbLitElement {
+	@state()
+	private _data?: UmbMyEntityDetailModel;
+
+	#workspaceContext?: typeof UMB_MY_ENTITY_WORKSPACE_CONTEXT.TYPE;
+
+	constructor() {
+		super();
+
+		this.consumeContext(UMB_MY_ENTITY_WORKSPACE_CONTEXT, (context) => {
+			this.#workspaceContext = context;
+
+			this.observe(context.data, (data) => {
+				this._data = data;
+			});
+		});
+	}
+
+	#onChange(event: Event) {
+		const value = (event.target as HTMLInputElement).value;
+		this.#workspaceContext?.setMyProperty(value);
+	}
+
+	override render() {
+		if (!this._data) return nothing;
+
+		return html`
+			<uui-box>
+				<umb-property-layout label=${this.localize.term('myEntity_myProperty')}>
+					<uui-input
+						slot="editor"
+						.value=${this._data.myProperty}
+						@input=${this.#onChange}></uui-input>
+				</umb-property-layout>
+			</uui-box>
+		`;
+	}
+}
+```
+
+### 7. Manifests
+
+```typescript
+export const manifests: Array<UmbExtensionManifest> = [
+	{
+		type: 'repository',
+		alias: 'Umb.Repository.MyEntity.Detail',
+		name: 'My Entity Detail Repository',
+		api: () => import('./my-entity-detail.repository.js'),
+	},
+	{
+		type: 'store',
+		alias: 'Umb.Store.MyEntity.Detail',
+		name: 'My Entity Detail Store',
+		api: () => import('./my-entity-detail.store.js'),
+	},
+];
+```
+
+Manifests are lazy-loaded — the `api: () => import(...)` pattern ensures code is only loaded when needed.
+
+---
+
+## Client-Side Models
+
+All layers above the data source work exclusively with **client-side domain models** — never with types from external systems (generated API types, third-party SDK types, etc.). The data source is the boundary where external types are mapped to client-side models and vice versa.
+
+**Why:** External models are shaped by their system's concerns (API versioning, serialization format, naming conventions). Client-side models are shaped by what the UI needs. Coupling the UI to external models means changes in any external system ripple through the entire frontend.
+
+**What to map:**
+
+| External concept | Client-side convention |
+|-----------------|----------------------|
+| `id`, `key`, `path`, `isoCode`, or any identifier | `unique` (standardized across all models) |
+| Entity classification | `entityType` (attached to models that represent entities) |
+| Server-specific field names | Domain-appropriate property names |
+| Nullable server fields with defaults | Resolved to concrete values where possible |
+
+**Where mapping happens:** Only in data sources. The data source reads external types, constructs a client-side model, and returns it. On writes, it does the reverse — takes a client-side model and constructs the external request type.
+
+```typescript
+// Data source maps server response → client-side model
+const model: UmbMyEntityDetailModel = {
+    entityType: UMB_MY_ENTITY_ENTITY_TYPE,
+    unique: data.id,        // server "id" → client "unique"
+};
+```
+
+**Rule:** If generated API types (`CreateXRequestModel`, `XResponseModel`, etc.) appear in a repository, context, or element import — the data source mapping layer is missing or incomplete.
+
+---
+
+## Key Rules
+
+1. **Never call generated API services directly from elements or contexts** — always go through data source → repository
+2. **Always use `tryExecute()` for API calls** — it handles errors and notifications
+3. **Data sources are the only layer that knows about external types** — they map between external system types and client-side domain models. No other layer should import or reference generated API types.
+4. **All return values use `{ data, error }` tuples** — never throw from async data operations
+5. **Export as `api` from repositories** — classes bound to a manifest use `export { ClassName as api }`, which enables lazy-loading via `api: () => import(...)`
+6. **Do not introduce new store types** — stores are being phased out. Manage state in the context layer using observable state classes directly
diff --git a/src/Umbraco.Web.UI.Client/docs/deprecation.md b/src/Umbraco.Web.UI.Client/docs/deprecation.md
new file mode 100644
index 000000000000..7c529858a0d2
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/docs/deprecation.md
@@ -0,0 +1,38 @@
+# Deprecation & Breaking Changes
+
+---
+
+The `@umbraco-cms/backoffice` npm package, Extension Registry, Context tokens, exported types, and global components form a public contract. Breaking changes require the deprecation process below.
+
+## SemVer & The 2-Major-Version Rule
+
+> If something is deprecated in **vN**, the earliest it can be removed is **vN+2**.
+>
+> Example: deprecated in v16 -> removed in v18 at the earliest.
+
+---
+
+## How to Deprecate
+
+Every deprecation must use **both** mechanisms:
+
+1. **JSDoc `@deprecated` tag** — for IDE warnings and documentation
+2. **Runtime warning via `UmbDeprecation`** — console output so consumers are notified at runtime
+
+For step-by-step implementation instructions, use the `general-deprecate-api` skill.
+
+---
+
+## What Counts as a Breaking Change
+
+Any of the following to a **publicly exported** symbol:
+
+- Removing/renaming an exported class, function, type, constant, or context token
+- Removing/renaming a public method or property
+- Changing a public method signature (required params, return type)
+- Removing/renaming a subpath export from `package.json`
+- Changing an extension type alias or manifest schema
+- Removing/renaming a global component's tag name
+- Changing public API behavior in unexpected ways
+
+**Not breaking**: Internal code (`local-components/`, unexported classes, private methods) can be changed freely.
diff --git a/src/Umbraco.Web.UI.Client/docs/entities.md b/src/Umbraco.Web.UI.Client/docs/entities.md
new file mode 100644
index 000000000000..20af207537e0
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/docs/entities.md
@@ -0,0 +1,178 @@
+# Entities & Entity Types
+
+The entity system is the **primary discriminator** that ties together workspaces, trees, actions, pickers, and routing. Most extension types in the backoffice are scoped to one or more entity types.
+
+---
+
+## Core Concept
+
+An **entity** is anything in the backoffice that needs to be identified and have extensions scoped to it. This includes obvious things like documents, media, and users, but also structural concepts like tree roots (`document-root`), folders (`data-type-folder`), and virtual groupings (`clipboard-root`, `extension-root`). Every entity is identified by two values:
+
+```typescript
+interface UmbEntityModel {
+  entityType: string;       // Type discriminator (e.g., 'document', 'media-root', 'data-type-folder')
+  unique: string | null;    // Instance identifier (GUID string, or null for roots/singletons)
+}
+```
+
+**entityType** is a string constant that classifies what something is. The extension system uses it to determine which actions, tree items, workspaces, and other extensions apply. It is the glue between independently-registered extensions.
+
+---
+
+## Defining Entity Types
+
+Each domain package defines its entity type constants in an `entity.ts` file:
+
+```typescript
+// src/packages/documents/documents/entity.ts
+export const UMB_DOCUMENT_ENTITY_TYPE = 'document';
+export const UMB_DOCUMENT_ROOT_ENTITY_TYPE = 'document-root';
+
+export type UmbDocumentEntityType = typeof UMB_DOCUMENT_ENTITY_TYPE;
+export type UmbDocumentRootEntityType = typeof UMB_DOCUMENT_ROOT_ENTITY_TYPE;
+```
+
+**Conventions:**
+- Constant: `UMB_{DOMAIN}_ENTITY_TYPE` (e.g., `UMB_MEDIA_ENTITY_TYPE`, `UMB_USER_ENTITY_TYPE`)
+- Root type: `UMB_{DOMAIN}_ROOT_ENTITY_TYPE` — represents the tree root (unique is `null`)
+- TypeScript type: `Umb{Domain}EntityType` — literal type derived via `typeof` for type-safe filtering
+- Union type: `Umb{Domain}EntityTypeUnion` — combines all entity types for a domain
+
+---
+
+## Entity Context
+
+`UmbEntityContext` (provided via `UMB_ENTITY_CONTEXT`) propagates the current entity's type and unique through the component tree. It is set by workspaces, tree items, and other entity-aware containers.
+
+```typescript
+// Consuming entity context in an element
+this.consumeContext(UMB_ENTITY_CONTEXT, (context) => {
+  this.observe(context.entityType, (entityType) => { /* react to type */ });
+  this.observe(context.unique, (unique) => { /* react to identity */ });
+});
+```
+
+Key file: `src/packages/core/entity/entity.context.ts`
+
+---
+
+## How Entity Types Connect Extensions
+
+Entity types are the **primary filter** for several extension types. Extensions declare which entity types they support via `forEntityTypes: string[]`:
+
+### Entity Actions
+
+Actions that appear in context menus and action bars for specific entity types:
+
+```typescript
+{
+  type: 'entityAction',
+  kind: 'delete',
+  alias: 'Umb.EntityAction.Document.Delete',
+  forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
+  meta: { /* ... */ },
+}
+```
+
+### Tree Items
+
+Custom tree item renderers for specific entity types:
+
+```typescript
+{
+  type: 'treeItem',
+  alias: 'Umb.TreeItem.Document',
+  forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
+  element: () => import('./document-tree-item.element.js'),
+}
+```
+
+### Entity Bulk Actions
+
+Bulk operations on multiple selected entities of a type:
+
+```typescript
+{
+  type: 'entityBulkAction',
+  alias: 'Umb.EntityBulkAction.Document.Delete',
+  forEntityTypes: [UMB_DOCUMENT_ENTITY_TYPE],
+}
+```
+
+### Entity Item Refs
+
+Custom renderers for entity references (used in pickers, relation displays):
+
+```typescript
+{
+  type: 'entityItemRef',
+  alias: 'Umb.EntityItemRef.Member',
+  forEntityTypes: [UMB_MEMBER_ENTITY_TYPE],
+  element: () => import('./member-item-ref.element.js'),
+}
+```
+
+At runtime, the system filters extensions by checking `extension.forEntityTypes.includes(currentEntityType)`.
+
+---
+
+## Workspaces & Routing
+
+Workspaces register with a specific entity type in their manifest `meta`:
+
+```typescript
+{
+  type: 'workspace',
+  kind: 'routable',
+  alias: 'Umb.Workspace.Document',
+  meta: {
+    entityType: UMB_DOCUMENT_ENTITY_TYPE,   // Routes to this workspace
+  },
+}
+```
+
+Entity type is part of the URL path pattern:
+
+```
+/section/{sectionName}/workspace/{entityType}/edit/{unique}
+```
+
+For example: `/section/content/workspace/document/edit/abc-123`
+
+The workspace context sets the entity type on `UMB_ENTITY_CONTEXT`, making it available to all child extensions (views, actions, sidebar apps).
+
+---
+
+## Entity Type Conditions
+
+Two built-in conditions control extension visibility based on entity state:
+
+**EntityTypeCondition** — matches the current entity context's type:
+```typescript
+conditions: [
+  { alias: 'Umb.Condition.EntityType', match: 'document' }
+]
+// or match multiple:
+conditions: [
+  { alias: 'Umb.Condition.EntityType', oneOf: ['document', 'media'] }
+]
+```
+
+**WorkspaceEntityTypeCondition** — matches the workspace's entity type (useful for workspace views/actions that should only appear for specific entity types):
+```typescript
+conditions: [
+  { alias: 'Umb.Condition.WorkspaceEntityType', match: 'document' }
+]
+```
+
+---
+
+## Adding a New Entity Type
+
+When creating a new domain feature, define its entity type first — everything else builds on it:
+
+1. **Define constants** in `entity.ts` (type constant + root type constant + TypeScript types)
+2. **Register extensions** with `forEntityTypes` pointing to your constant (tree items, actions, item refs)
+3. **Register workspace** with `meta.entityType` pointing to your constant
+4. **Define paths** using `UMB_WORKSPACE_PATH_PATTERN` with your entity type
+5. **Use entity context** in workspace contexts and elements to propagate identity
diff --git a/src/Umbraco.Web.UI.Client/docs/package-development.md b/src/Umbraco.Web.UI.Client/docs/package-development.md
new file mode 100644
index 000000000000..1caa786bdd12
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/docs/package-development.md
@@ -0,0 +1,121 @@
+# Package Development
+
+---
+
+How to structure, organize, and build packages within the Umbraco Backoffice frontend. For architecture concepts (extension registry, context API, repository pattern), see [Architecture](./architecture.md). For import boundary rules, see [Developer Roles](./architecture.md#developer-roles--import-boundaries).
+
+---
+
+## Package & Module Structure
+
+Each top-level folder under `src/packages/` is a **package root**. A package contains one or more **modules**, each in its own subfolder.
+
+```
+src/packages/media/          <- package root
+├── media/                   <- module (media management)
+│   ├── index.ts
+│   ├── manifests.ts
+│   └── ...
+├── imaging/                 <- module (image processing)
+│   ├── index.ts
+│   ├── manifests.ts
+│   └── ...
+├── manifests.ts             <- aggregates all module manifests
+└── umbraco-package.ts       <- bundle entry point
+```
+
+### Public vs. Private Modules
+
+A module becomes public by adding an import map entry in the root `package.json` exports field (see [Registering Package Module Export](#registering-package-module-export)). Only export modules with a clear external use case.
+
+- The public API (`index.ts` + `package.json` export) is a contract with consumers.
+- Keep code private until needed — non-exported code can be freely refactored.
+- Once exported, changes require the [deprecation process](./deprecation.md).
+
+---
+
+## Folder Structure Conventions
+
+**Sub-folders are organized by sub-feature, not by technical role.** Each sub-feature folder contains everything related to that feature — elements, repository, store, modals, actions, constants, types, and manifests. No top-level `repositories/`, `modals/`, or `actions/` folders.
+
+- Every sub-feature is self-contained (full vertical slice). Deleting the folder should break nothing outside it (apart from the missing manifest registration).
+- Every folder with registerable items has its own `manifests.ts`. Child manifests bubble up to the package root.
+- Every sub-feature has `index.ts`, `manifests.ts`, and `constants.ts` at minimum. Add `types.ts` for shared types.
+
+### `local-components/`
+
+Elements only used within a sub-feature go in `local-components/`. Never exported — private implementation details.
+
+### `global-components/`
+
+Reusable elements for other packages. Must be registered as custom elements at startup and exported from the package's `index.ts`.
+
+```typescript
+@customElement('umb-feature')
+export class UmbFeatureElement extends UmbLitElement {
+  render() { return html`Feature Element`; }
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    ['umb-feature']: UmbFeatureElement;
+  }
+}
+```
+
+### Manifest Bubbling
+
+Each sub-feature exports its own `manifests` array. The package-level `manifests.ts` aggregates them:
+
+```typescript
+import { manifests as sectionManifests } from './section/manifests.js';
+import { manifests as dashboardManifests } from './dashboard/manifests.js';
+export const manifests = [...sectionManifests, ...dashboardManifests];
+```
+
+---
+
+## The Package's Public API (index.ts)
+
+Only export what constitutes the public contract — context tokens, types, constants, and global component classes. **Manifests are NOT exported from `index.ts`** — they are registered internally via the bundle mechanism.
+
+---
+
+## Registering Package Module Export
+
+To make a module importable by other packages:
+
+1. Add the subpath to `package.json` exports:
+```json
+{ "exports": { "./module": "./dist-cms/packages/package/module/index.js" } }
+```
+
+2. Run the generators:
+```bash
+npm i && npm run generate:tsconfig
+```
+
+This ensures TypeScript, the browser import map, and test configs all resolve the new package.
+
+---
+
+## Localization
+
+No hardcoded UI-facing strings. All user-visible text must go through the localization system. Keys live in `src/assets/lang/en.ts`, grouped by feature area, referenced as `group_keyName` (e.g., `this.localize.term('actions_create')`).
+
+For step-by-step instructions on adding localization keys and using them in elements or controllers, use the `general-add-localization` skill.
+
+---
+
+## Conventions & Rules
+
+1. **Never import from `dist-cms/` directly.** Always use `@umbraco-cms/backoffice/<subpath>`.
+2. **Every new module export must be added to `package.json` exports** and regenerated.
+3. **Use `UmbLitElement` or `UmbElementMixin`** as base class — never raw `LitElement`.
+4. **Export `api`** from files providing a class for the extension registry to instantiate (workspace contexts, actions).
+5. **Use element lazy loading** in manifests: `element: () => import('./path.js')`.
+6. **Use `@umbraco-ui/uui` components** for UI consistency (`<uui-box>`, `<uui-button>`, `<uui-input>`, etc.).
+7. **Declare custom manifest types** on `UmbExtensionManifestMap` so other packages can extend yours.
+8. **No hardcoded UI strings** — use the localization system. See [Localization](#localization) above and the `general-add-localization` skill.
+9. **Element naming**: `umb-` prefix for core. Package developers use their own prefix.
+10. **Extension aliases**: Dot-separated namespace (`Umb.Section.Content`, `My.Dashboard.Analytics`).
diff --git a/src/Umbraco.Web.UI.Client/docs/repositories.md b/src/Umbraco.Web.UI.Client/docs/repositories.md
new file mode 100644
index 000000000000..f5f559f2b12e
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/docs/repositories.md
@@ -0,0 +1,194 @@
+# Repositories
+
+How data access is organized across features. Repositories separate **where data comes from** from the UI that consumes it — the UI never knows whether data comes from a server API, a manifest, or a local cache.
+
+For the full data flow chain (element → context → repository → data source → API client), see [Data Flow](./data-flow.md). This document focuses on how repositories are structured, categorized, and organized within the codebase.
+
+---
+
+## Core Concept
+
+A repository is a **domain-specific, feature-scoped** data access layer. It provides a clean interface for a specific operation (CRUD, listing, tree navigation, or a specialized action) without exposing transport details.
+
+**Key principles:**
+
+- **Feature-scoped** — A repository lives with the feature that uses it, both in naming and file location. A publishing repository lives inside the publishing feature folder, not in a generic repository folder.
+- **Extension-registered** — Repositories are registered as `type: 'repository'` extensions with lazy-loaded `api` imports. Any extension can override a repository by registering the same alias with a higher weight.
+- **Data source delegation** — The repository orchestrates but doesn't call APIs directly. It delegates to a data source that handles mapping between server types and domain models. See [Data Flow](./data-flow.md) for the full delegation pattern.
+- **One concern per repository** — A detail repository handles CRUD. A publishing repository handles publish/unpublish. Don't mix concerns.
+
+---
+
+## Repository Categories
+
+Repositories fall into two groups: **standard** (backed by base classes) and **action-specific** (custom, feature-driven).
+
+### Standard Repositories
+
+These have base classes in `src/packages/core/` that handle the boilerplate.
+
+| Category | Base Class | Purpose | Interface |
+|----------|-----------|---------|-----------|
+| **Detail** | `UmbDetailRepositoryBase<T>` | CRUD for a single entity | `UmbDetailRepository<T>` |
+| **Item** | `UmbItemRepositoryBase<T>` | Batch fetch multiple items by unique IDs | `UmbItemRepository<T>` |
+| **Tree** | `UmbTreeRepositoryBase<T, R>` | Hierarchical navigation (root, children, ancestors) | `UmbTreeRepository<T, R>` |
+| **Collection** | *(no base class — extend `UmbRepositoryBase`)* | Paginated/filtered lists | `UmbCollectionRepository<T, F>` |
+
+**Detail** is the most common — every entity that can be created, read, updated, or deleted needs one.
+
+**Item** is for lightweight lookups — fetching display info (name, icon, entity type) for a set of known IDs. Used by pickers, references, and breadcrumbs.
+
+**Tree** is for entities with hierarchical navigation in the sidebar — documents, media, document types.
+
+**Collection** is for flat or filtered lists — the grid/table view of entities.
+
+### Action-Specific Repositories
+
+These are custom repositories for operations that don't fit CRUD. They extend `UmbRepositoryBase` or `UmbControllerBase` directly and define their own methods.
+
+Examples from the document entity:
+
+| Repository | Purpose | Methods |
+|-----------|---------|---------|
+| `UmbDocumentPublishingRepository` | Publish/unpublish variants | `publish()`, `unpublish()`, `publishWithDescendants()`, `published()` |
+| `UmbDuplicateDocumentRepository` | Duplicate a document | `requestDuplicate()` |
+| `UmbDocumentCultureAndHostnamesRepository` | Domain/culture assignments | `readCultureAndHostnames()`, `updateCultureAndHostnames()` |
+| `UmbBulkMoveToDocumentRepository` | Bulk move action | `requestBulkMoveTo()` |
+
+Action-specific repositories follow the same data source delegation pattern but define domain-appropriate methods instead of generic CRUD.
+
+---
+
+## File Structure & Naming
+
+Repositories live **with their feature**, not in a separate data-access layer. The folder structure mirrors the feature hierarchy.
+
+### Standard repositories (detail, item)
+
+```
+{package}/{entity}/
+├── detail/
+│   └── data/
+│       ├── {entity}-detail.repository.ts
+│       ├── {entity}-detail.server.data-source.ts
+│       ├── {entity}-detail.store.ts
+│       ├── {entity}-detail.store.context-token.ts
+│       ├── manifests.ts
+│       └── constants.ts
+├── item/                                  # Optional — only if entity needs item lookups
+│   └── data/
+│       ├── {entity}-item.repository.ts
+│       ├── {entity}-item.server.data-source.ts
+│       ├── {entity}-item.store.ts
+│       ├── {entity}-item.store.context-token.ts
+│       └── manifests.ts
+```
+
+### Tree repository
+
+```
+{package}/{entity}/
+├── tree/
+│   └── data/
+│       ├── {entity}-tree.repository.ts
+│       ├── {entity}-tree.server.data-source.ts
+│       ├── {entity}-tree.store.context-token.ts
+│       └── manifests.ts
+```
+
+### Collection repository
+
+```
+{package}/{entity}/
+├── collection/
+│   └── data/
+│       ├── {entity}-collection.repository.ts
+│       ├── {entity}-collection.server.data-source.ts
+│       └── manifests.ts
+```
+
+### Action-specific repositories
+
+```
+{package}/{entity}/
+├── entity-actions/
+│   ├── duplicate/
+│   │   └── data/
+│   │       ├── {entity}-duplicate.repository.ts
+│   │       ├── {entity}-duplicate.server.data-source.ts
+│   │       └── types.ts
+│   ├── move-to/
+│   │   └── data/
+│   │       └── ...
+│   └── culture-and-hostnames/
+│       └── data/
+│           └── ...
+├── entity-bulk-actions/
+│   ├── move-to/
+│   │   └── data/
+│   │       └── ...
+│   └── duplicate-to/
+│       └── data/
+│           └── ...
+├── publishing/
+│   └── data/
+│       ├── {entity}-publishing.repository.ts
+│       └── {entity}-publishing.server.data-source.ts
+```
+
+### Naming conventions
+
+| Item | Pattern | Example |
+|------|---------|---------|
+| Repository class | `Umb{EntityName}{Category}Repository` | `UmbDocumentDetailRepository` |
+| Data source class | `Umb{EntityName}{Category}ServerDataSource` | `UmbDocumentDetailServerDataSource` |
+| Repository file | `{entity}-{category}.repository.ts` | `document-detail.repository.ts` |
+| Data source file | `{entity}-{category}.server.data-source.ts` | `document-detail.server.data-source.ts` |
+| Manifest alias | `Umb.Repository.{EntityName}.{Category}` | `Umb.Repository.Document.Detail` |
+| Store alias | `Umb.Store.{EntityName}.{Category}` | `Umb.Store.Document.Detail` |
+
+---
+
+## When to Create Which Repository Type
+
+| Scenario | Repository type | Base class |
+|----------|----------------|------------|
+| Entity with create/read/update/delete | Detail | `UmbDetailRepositoryBase<T>` |
+| Fetching display info for known IDs (pickers, breadcrumbs) | Item | `UmbItemRepositoryBase<T>` |
+| Sidebar tree navigation | Tree | `UmbTreeRepositoryBase<T, R>` |
+| Paginated/filtered listing | Collection | `UmbRepositoryBase` + `UmbCollectionRepository<T>` |
+| Domain action (publish, duplicate, move, sort) | Action-specific | `UmbRepositoryBase` or `UmbControllerBase` |
+
+**Rule of thumb:** If there's a base class for it, use it. If the operation is unique to the domain, create a custom repository with just the methods needed.
+
+---
+
+## Reference Examples
+
+Study these when implementing repositories:
+
+| Pattern | Example path | What it shows |
+|---------|-------------|---------------|
+| Simple detail + item | `src/packages/webhook/webhook/repository/` | Minimal CRUD entity |
+| Full entity (detail + item + tree + collection) | `src/packages/documents/documents/` | All repository categories |
+| Action-specific (simple) | `src/packages/documents/documents/entity-actions/duplicate/repository/` | Single-action with notification |
+| Action-specific (domain-rich) | `src/packages/documents/documents/publishing/repository/` | Multiple domain methods |
+| Action-specific (read/write) | `src/packages/documents/documents/entity-actions/culture-and-hostnames/repository/` | Custom read + update |
+| Data type as reference | `src/packages/data-type/` | Detail + item + tree + collection |
+
+---
+
+## Key Rules
+
+1. **Repositories live with their feature** — colocated in the feature's directory, not in a shared `repositories/` folder
+2. **One concern per repository** — detail CRUD, publishing, duplication, and tree navigation are separate repositories
+3. **Use base classes when they exist** — only create custom repositories for operations without a base class
+4. **Always delegate to a data source** — see [Data Flow](./data-flow.md) for the delegation pattern, `tryExecute`, and `{ data, error }` tuple conventions
+
+---
+
+## Classify by Operations, Not by Neighbors
+
+When creating or reviewing a repository, determine its **category** based on what operations it performs — not based on what nearby files look like. Then verify it uses the correct base class, interfaces, and data flow conventions for that category.
+
+Use the [When to Create Which Repository Type](#when-to-create-which-repository-type) table as the decision guide. If the operations map to a standard category, the repository must use the corresponding base class and interfaces. A repository should only extend `UmbRepositoryBase` directly when no standard category fits.
diff --git a/src/Umbraco.Web.UI.Client/docs/style-guide.md b/src/Umbraco.Web.UI.Client/docs/style-guide.md
index d45ba73fd83c..4e5ab4527d2c 100644
--- a/src/Umbraco.Web.UI.Client/docs/style-guide.md
+++ b/src/Umbraco.Web.UI.Client/docs/style-guide.md
@@ -196,6 +196,16 @@ export class UmbBadElement extends LitElement {
 - `@cssprop` - CSS custom properties
 - `@csspart` - CSS parts
 
+### Third-Party Library Names
+
+Use the correct capitalization for third-party libraries:
+
+| Library | Correct | Incorrect              |
+|---------|---------|------------------------|
+| Tiptap  | Tiptap  | TipTap, tipTap, TIPTAP |
+| Lit     | Lit     | LIT, lit (in prose)    |
+| RxJS    | RxJS    | rxjs (in prose), RXJS  |
+
 ### Documentation
 
 - **Public APIs**: JSDoc comments with `@description`, `@param`, `@returns`, `@example`
diff --git a/src/Umbraco.Web.UI.Client/docs/testing.md b/src/Umbraco.Web.UI.Client/docs/testing.md
index b1ed63ee05b6..28ae99db4f26 100644
--- a/src/Umbraco.Web.UI.Client/docs/testing.md
+++ b/src/Umbraco.Web.UI.Client/docs/testing.md
@@ -1,8 +1,25 @@
 # Testing
-[← Umbraco Backoffice](../CLAUDE.md) | [← Monorepo Root](../../CLAUDE.md)
 
 ---
 
+## Testing Strategy
+
+The project uses two layers of testing:
+
+1. **Client-side tests** (this project) — Unit and integration tests running in-browser via `@web/test-runner`. API calls are intercepted by **MSW (Mock Service Worker)** request handlers, providing realistic mocked responses without a running backend.
+2. **E2E acceptance tests** (`tests/Umbraco.Tests.AcceptanceTest/`) — Playwright tests running against a real CMS installation. These live outside the client project and cover full user journeys end-to-end.
+
+### Testing Priority by Code Area
+
+All tests matter, but some code changes carry more risk than others. The closer code is to the foundation, the wider the blast radius when it breaks — and the more critical it is to have test coverage.
+
+| Priority | Area | Rationale |
+|----------|------|-----------|
+| **Critical** | `src/libs/` | Framework foundations used by everything. Changes here **must** have tests. |
+| **High** | `src/packages/core/` | UI framework infrastructure. Classes (contexts, controllers, managers, repositories) should be covered by unit tests. Element tests are important but secondary. |
+| **Standard** | `src/packages/*` (CMS packages) | Domain features. Tests are valuable and encouraged, but these areas also have coverage from the E2E acceptance tests. |
+
+This is not a reason to skip tests for CMS packages — it's a guide for where to invest testing effort first when time is limited.
 
 ### Testing Philosophy
 
@@ -186,21 +203,17 @@ test.describe('Content Editor', () => {
 
 ### Mocking Best Practices
 
-**MSW (Mock Service Worker)** for API mocking:
+**MSW (Mock Service Worker)** for API mocking. MSW intercepts requests at the network level — tests hit the same code paths as production, with realistic responses. Handlers are defined in `src/mocks/handlers/` and loaded globally before tests run.
 
 ```typescript
-import { rest } from 'msw';
+const { http, HttpResponse } = window.MockServiceWorker;
 
 export const handlers = [
-	rest.get('/umbraco/management/api/v1/document/:id', (req, res, ctx) => {
-		const { id } = req.params;
-		return res(
-			ctx.json({
-				id,
-				name: 'Test Document',
-				// ... mock data
-			})
-		);
+	http.get('/umbraco/management/api/v1/document/:id', ({ params }) => {
+		return HttpResponse.json({
+			id: params.id,
+			name: 'Test Document',
+		});
 	}),
 ];
 ```
diff --git a/src/Umbraco.Web.UI.Client/docs/workspaces.md b/src/Umbraco.Web.UI.Client/docs/workspaces.md
new file mode 100644
index 000000000000..bcdfefa53981
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/docs/workspaces.md
@@ -0,0 +1,348 @@
+# Workspaces
+
+Workspaces are the primary editing surfaces in the backoffice. Each workspace holds a **context** (state + behavior), **views** (tabs), and **actions** (toolbar buttons) for a specific entity or feature. All workspace infrastructure lives in `src/packages/core/workspace/`; each entity implements its own workspace in its domain package.
+
+Workspaces are registered and composed through the **extension system** — the same mechanism used for all backoffice UI. This means any workspace can be extended, overridden, or replaced by any package.
+
+**Prerequisites**: [Entities](./entities.md), [Core Primitives](./core-primitives.md), [Data Flow](./data-flow.md)
+
+---
+
+## Extension Types for Workspaces
+
+Workspace *views, actions, contexts, and footer apps* typically use **conditions** to scope to a specific workspace, while the `workspace` manifest itself is matched by `meta.entityType`.
+
+| Extension Type | Purpose | Key Config |
+|---|---|---|
+| `workspace` | The workspace itself | `kind` (`default`/`routable`), `api` (context class), `meta.entityType` |
+| `workspaceView` | Tabs/views within workspace | `element`/`js` (lazy), `meta.label`, `meta.pathname`, `meta.icon`, `weight`, `conditions` |
+| `workspaceAction` | Toolbar actions (save, publish) | `kind`, `api` (action class), `meta.look`, `meta.color`, `meta.label`, `conditions` |
+| `workspaceActionMenuItem` | Dropdown items on actions | `forWorkspaceActions` (target action alias), `conditions` |
+| `workspaceContext` | Additional composable contexts | `api` (lazy), `conditions` |
+| `workspaceFooterApp` | Footer components | `kind` (`menuBreadcrumb`, `variantMenuBreadcrumb`), `conditions` |
+
+### How extensions are discovered
+
+1. `umb-workspace` element finds the `workspace` extension matching the entity type
+2. Once the workspace context (API) is created, `UmbExtensionsApiInitializer` loads all matching `workspaceContext` extensions
+3. `umb-workspace-editor` discovers `workspaceView` extensions via `UmbExtensionsManifestInitializer`
+4. `umb-workspace-footer` discovers `workspaceAction` extensions via `umb-extension-with-api-slot`
+
+Key file: `src/packages/core/workspace/workspace.element.ts`
+
+---
+
+## Workspace Kinds
+
+Two built-in kinds provide the workspace shell and context. Start with `default`; use `routable` when you need create/edit URL routing.
+
+### `default` — The Foundation
+
+The simplest workspace. Provides a headline, renders `<umb-workspace-editor>`, and supports workspace views, actions, workspace contexts, and footer apps — all with **zero custom code**. Just register a manifest.
+
+```typescript
+{
+  type: 'workspace',
+  kind: 'default',
+  alias: 'Umb.Workspace.WebhookRoot',
+  name: 'Webhook Root Workspace',
+  meta: {
+    entityType: UMB_WEBHOOK_ROOT_ENTITY_TYPE,
+    headline: '#treeHeaders_webhooks',
+  },
+}
+```
+
+**What you get out of the box:**
+- `UmbDefaultWorkspaceContext` — implements `UmbWorkspaceContext`, sets up `UmbEntityContext` and `UmbViewContext`
+- `<umb-default-workspace>` element — renders `<umb-workspace-editor>` with the localized headline
+- Full support for `workspaceView`, `workspaceAction`, `workspaceContext`, and `workspaceFooterApp` extensions scoped via conditions
+- Entity context propagation (`entityType` + `unique`)
+
+**No custom context class or element needed.** The kind provides both.
+
+**`meta` config:**
+- `entityType` (required) — the entity type constant
+- `headline` (required) — workspace title, supports localization keys (e.g., `'#treeHeaders_webhooks'`)
+
+**Common pattern:** Default workspaces often pair with a `workspaceView` of `kind: 'collection'` to list child entities. See `src/packages/webhook/webhook-root/workspace/manifests.ts` for a complete example.
+
+**Kind implementation:** `src/packages/core/workspace/kinds/default/`
+
+**Base interface** (`UmbWorkspaceContext`):
+```typescript
+interface UmbWorkspaceContext extends UmbApi, UmbContextMinimal {
+  readonly workspaceAlias: string;
+  getEntityType(): string;
+}
+```
+
+This is the minimal contract all workspace contexts satisfy. The default kind implements it automatically.
+
+### `routable` — Entity Detail Editing
+
+Used when the workspace needs internal URL routing (create/edit flows). The workspace element renders an `umb-router-slot` that delegates to routes defined by the workspace context. **Requires a custom context class** that sets up routes.
+
+```typescript
+{
+  type: 'workspace',
+  kind: 'routable',
+  alias: 'Umb.Workspace.Webhook',
+  name: 'Webhook Workspace',
+  api: () => import('./webhook-workspace.context.js'),
+  meta: { entityType: UMB_WEBHOOK_ENTITY_TYPE },
+}
+```
+
+**What differs from default:**
+- You must provide `api` — a context class that implements `UmbRoutableWorkspaceContext` and calls `this.routes.setRoutes(...)`
+- You must provide a custom editor element (rendered by the routes)
+- The kind only provides the router shell (`<umb-router-slot>`), not the workspace editor UI
+
+**Kind implementation:** `src/packages/core/workspace/kinds/routable/routable-workspace.kind.ts`
+
+---
+
+## Base Class Hierarchy (for Routable Workspaces)
+
+When building a routable workspace, you typically extend one of these base classes. Each layer adds functionality:
+
+```
+UmbContextBase
+  └── UmbSubmittableWorkspaceContextBase<WorkspaceDataModelType>
+       └── UmbEntityDetailWorkspaceContextBase<DetailModelType, DetailRepositoryType, CreateArgsType>
+            └── UmbEntityNamedDetailWorkspaceContextBase<NamedDetailModelType, ...>
+```
+
+### UmbSubmittableWorkspaceContextBase
+
+**File**: `src/packages/core/workspace/submittable/submittable-workspace-context-base.ts`
+
+Foundation for any workspace that supports form submission:
+- `workspaceAlias` — identifier matching the manifest alias
+- `routes` — `UmbWorkspaceRouteManager` for internal routing
+- `isNew` observable — tracks whether the entity is being created
+- `requestSubmit()` → `validate()` → abstract `submit()` pipeline
+- Multiple `UmbValidationContext` support for composable validation
+- Keyboard shortcut: Ctrl+S triggers submit
+- Modal integration (workspace can be opened in a modal dialog)
+
+### UmbEntityDetailWorkspaceContextBase
+
+**File**: `src/packages/core/workspace/entity-detail/entity-detail-workspace-base.ts`
+
+Adds entity detail CRUD lifecycle on top of submittable:
+- `UmbEntityWorkspaceDataManager` — dual-state data management (persisted vs. current) with change detection
+- `load(unique)` — fetch entity from repository, observe for real-time updates
+- `createScaffold(args)` — create new entity with optional preset data and parent
+- `submit()` — routes to `_create()` or `_update()` based on `isNew`
+- `delete(unique)` — delete entity via repository
+- `validationContext` — base validation context (always present)
+- `loading` / `forbidden` state managers
+- Navigation-away guard (unsaved changes modal)
+- Event dispatching for tree refresh after create/update
+
+**Constructor args** (`UmbEntityDetailWorkspaceContextArgs`):
+```typescript
+{ workspaceAlias: string, entityType: string, detailRepositoryAlias: string }
+```
+
+### UmbEntityNamedDetailWorkspaceContextBase
+
+**File**: `src/packages/core/workspace/entity-detail/entity-named-detail-workspace-base.ts`
+
+Adds name management for entities with a `name` property:
+- `name` observable — derived from current data
+- `getName()` / `setName()` convenience methods
+- `nameWriteGuard` — `UmbNameWriteGuardManager` for permission checking
+- Auto-syncs view title from name changes
+
+**This is the base class most entity detail workspaces extend.**
+
+**Editor element pattern**: Use `<umb-workspace-header-name-editable slot="header">` inside `<umb-entity-detail-workspace-editor>`. This built-in element auto-consumes the workspace context for name binding, validation (`umbBindToValidation`), write guard permissions, auto-focus, and localization — no manual name wiring needed. See `src/packages/core/workspace/components/workspace-header-name-editable/`.
+
+---
+
+## Workspace Context Extensions (Modularity & Reuse)
+
+**This is the most important pattern for maintaining package boundaries and enabling cross-workspace reuse.**
+
+`workspaceContext` extensions let any package add capabilities to a workspace without modifying the workspace's own code. The owning package registers the extension; it activates only when the target workspace is open. This works for both `default` and `routable` workspaces.
+
+Workspace contexts serve two purposes:
+1. **Modularity** — Keep features in their own package, not in the workspace's package
+2. **Reuse** — The same capability (publishing, menu structure, permissions) can be added to multiple workspaces via separate registrations or shared base classes
+
+### Registration pattern
+
+```typescript
+// In: src/packages/documents/documents/publishing/workspace-context/manifests.ts
+{
+  type: 'workspaceContext',
+  alias: 'Umb.WorkspaceContext.Document.Publishing',
+  api: () => import('./document-publishing.workspace-context.js'),
+  conditions: [
+    { alias: UMB_WORKSPACE_CONDITION_ALIAS, match: UMB_DOCUMENT_WORKSPACE_ALIAS },
+  ],
+}
+```
+
+### Implementation pattern
+
+The context class extends `UmbContextBase`, consumes the parent workspace context, and provides its own context token:
+
+```typescript
+export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase
+  implements UmbPublishableWorkspaceContext {
+
+  constructor(host: UmbControllerHost) {
+    super(host, UMB_DOCUMENT_PUBLISHING_WORKSPACE_CONTEXT.toString());
+
+    this.consumeContext(UMB_DOCUMENT_WORKSPACE_CONTEXT, (workspaceContext) => {
+      // Access workspace data and add publishing capabilities
+    });
+  }
+
+  async saveAndPublish() { /* ... */ }
+  async publish() { /* ... */ }
+  async unpublish() { /* ... */ }
+}
+```
+
+Other components consume this via its token:
+```typescript
+this.consumeContext(UMB_DOCUMENT_PUBLISHING_WORKSPACE_CONTEXT, (ctx) => { /* ... */ });
+```
+
+### Deep example: Document Publishing
+
+The best example of a full-stack workspace context extension. The publishing feature has its own repository, data source, workspace actions, and keyboard shortcuts — all layered on top of the document workspace via a `workspaceContext` registration.
+
+**Key principles:** own repository & endpoints (separate from document detail), consumes parent workspace context for entity data, implements a core interface (`UmbPublishableWorkspaceContext` in `src/packages/core/workspace/contexts/tokens/`), and registers its own workspace actions that delegate to the publishing context.
+
+**Reference:** `src/packages/documents/documents/publishing/`
+
+### Reuse patterns
+
+1. **Shared base classes** — A base class in core provides common logic; entity-specific subclasses just pass configuration (e.g., `UmbMenuVariantTreeStructureWorkspaceContextBase` used by both document and media menu structure contexts, each passing their own tree repository alias).
+
+2. **Multiple registrations** — The same context class registered for different workspaces with different conditions (e.g., property value permissions registered for both document and block workspaces).
+
+### Package boundary rules
+
+- **The package that owns the feature registers the workspaceContext**, not the workspace's package
+- Views and actions from other packages use conditions to target the workspace alias
+- Never import internal files from another package — use public `index.ts` exports
+
+### Kinds for workspace contexts
+
+Workspace contexts can use kinds for shared patterns:
+
+```typescript
+{
+  type: 'workspaceContext',
+  kind: 'menuStructure',  // Provides pre-built breadcrumb/menu behavior
+  alias: 'Umb.Context.Media.Menu.Structure',
+  api: () => import('./media-menu-structure.context.js'),
+  meta: { menuItemAlias: UMB_MEDIA_MENU_ITEM_ALIAS },
+  conditions: [{ alias: UMB_WORKSPACE_CONDITION_ALIAS, match: UMB_MEDIA_WORKSPACE_ALIAS }],
+}
+```
+
+---
+
+## Save/Submit Flow
+
+### Simple save (most entities)
+
+1. User clicks **Save** button (or Ctrl+S)
+2. `UmbSubmitWorkspaceAction.execute()` calls `workspaceContext.requestSubmit()`
+3. `requestSubmit()` runs all registered `UmbValidationContext` validators
+4. If valid → calls abstract `submit()`
+5. `submit()` in `UmbEntityDetailWorkspaceContextBase`:
+   - If `isNew` → `_create(data, parent)` → `repository.create(data, parentUnique)`
+   - If existing → `_update(data)` → `repository.save(data)`
+6. Updates persisted + current data from response
+7. Dispatches events: `UmbRequestReloadChildrenOfEntityEvent` (create), `UmbRequestReloadStructureForEntityEvent`, `UmbEntityUpdatedEvent` (update)
+8. If opened in modal → resolves modal value and closes
+
+### Built-in action classes
+
+| Class | File | Consumes | Calls |
+|---|---|---|---|
+| `UmbSubmitWorkspaceAction` | `src/packages/core/workspace/components/workspace-action/common/submit/submit.action.ts` | `UMB_SUBMITTABLE_WORKSPACE_CONTEXT` | `requestSubmit()` |
+| `UmbSaveWorkspaceAction` | `src/packages/core/workspace/components/workspace-action/common/save/save.action.ts` | `UMB_SAVEABLE_WORKSPACE_CONTEXT` | `requestSave()` |
+
+Most simple entities use `UmbSubmitWorkspaceAction` directly (no custom action class needed). Complex entities like documents define custom action classes for variant dialogs, permission checks, etc.
+
+---
+
+## Route Patterns
+
+Routable workspaces define internal routes in the context constructor via `this.routes.setRoutes()`. Two patterns exist:
+
+- **Simple** (flat entities) — `create` route with fixed parent, `edit/:unique` route for existing entities
+- **Parent-aware** (tree entities) — `create/parent/:entityType/:parentUnique` route that extracts parent from URL params
+
+Both patterns use **`UmbWorkspaceIsNewRedirectController`** in the create route — it observes the workspace's `isNew` state and replaces the URL from `/create` to `/edit/:unique` after the first save. The edit route must call `removeUmbControllerByAlias(UmbWorkspaceIsNewRedirectControllerAlias)` to clean up.
+
+File: `src/packages/core/workspace/controllers/workspace-is-new-redirect.controller.ts`
+
+---
+
+## Workspace Conditions
+
+Built-in conditions for scoping extensions to specific workspaces:
+
+| Condition Alias | Config | Purpose |
+|---|---|---|
+| `Umb.Condition.WorkspaceAlias` | `match: string` or `oneOf: string[]` | Match workspace by alias |
+| `Umb.Condition.WorkspaceEntityType` | `match: string` or `oneOf: string[]` | Match entity type |
+| `Umb.Condition.WorkspaceEntityIsNew` | — | True when entity is being created |
+| `Umb.Condition.WorkspaceIsLoaded` | — | True when workspace data has loaded |
+
+The most common is `Umb.Condition.WorkspaceAlias` (constant: `UMB_WORKSPACE_CONDITION_ALIAS`), used by virtually all workspace views and actions.
+
+Files: `src/packages/core/workspace/conditions/`
+
+---
+
+## Context Token Pattern
+
+Every routable workspace exposes a typed context token so views, actions, and workspace context extensions can consume it with type safety. The token uses `UmbContextToken` with two generics: the base interface (`UmbSubmittableWorkspaceContext`) and the concrete context class. The context string is always `'UmbWorkspaceContext'`, and a discriminator function checks `getEntityType()` to find the right workspace context in the DOM tree.
+
+Re-export the token from `constants.ts` for the public API. Default workspaces don't need a custom context token — they use `UMB_WORKSPACE_CONTEXT` from core.
+
+---
+
+## Data Management
+
+The `UmbEntityWorkspaceDataManager` (`src/packages/core/workspace/entity/entity-workspace-data-manager.ts`) provides dual-state data tracking for routable entity detail workspaces:
+
+- **`persisted`** — last saved state from the server
+- **`current`** — working copy with user edits
+
+Key methods on workspace context (via `this._data`):
+```typescript
+// Create observables for specific properties
+readonly myProp = this._data.createObservablePartOfCurrent((data) => data?.myProp);
+
+// Read/write current data
+this._data.getCurrent()?.myProp
+this._data.updateCurrent({ myProp: newValue })
+
+// Change detection
+this._data.getHasUnpersistedChanges()  // JSON comparison
+this._data.resetCurrent()              // Revert to persisted
+```
+
+---
+
+## Reference Examples
+
+| Kind | Complexity | Path | Notes |
+|---|---|---|---|
+| `default` | — | `src/packages/webhook/webhook-root/workspace/` | Root + collection view |
+| `routable` | Simple | `src/packages/webhook/webhook/workspace/` | Single view, flat data |
+| `routable` | Medium | `src/packages/data-type/workspace/` | Two views, invariant dataset |
+| `routable` | Complex | `src/packages/documents/documents/workspace/` | Variants, publishing, permissions |
diff --git a/src/Umbraco.Web.UI.Client/examples/manifest-picker/manifest-picker-dashboard.ts b/src/Umbraco.Web.UI.Client/examples/manifest-picker/manifest-picker-dashboard.ts
index e2af9cc43f11..9ccda52f397f 100644
--- a/src/Umbraco.Web.UI.Client/examples/manifest-picker/manifest-picker-dashboard.ts
+++ b/src/Umbraco.Web.UI.Client/examples/manifest-picker/manifest-picker-dashboard.ts
@@ -3,11 +3,11 @@ import { umbExtensionsRegistry } from '@umbraco-cms/backoffice/extension-registr
 import type { UmbInputManifestElement } from '@umbraco-cms/backoffice/components';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
-import type { UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 
 @customElement('example-manifest-picker-dashboard')
 export class ExampleManifestPickerDashboardElement extends UmbLitElement {
-	#options: Array<Option> = [];
+	#options: Array<UUISelectOption> = [];
 
 	@state()
 	private _selectedExtensionType: string = 'collectionView';
diff --git a/src/Umbraco.Web.UI.Client/index.html b/src/Umbraco.Web.UI.Client/index.html
index e254fba60033..e921ec88d67c 100644
--- a/src/Umbraco.Web.UI.Client/index.html
+++ b/src/Umbraco.Web.UI.Client/index.html
@@ -7,7 +7,7 @@
 		<title>Umbraco</title>
 		<link rel="icon" type="image/svg+xml" href="./umbraco/backoffice/assets/favicon.svg" />
 		<link rel="stylesheet" href="src/css/umb-css.css" />
-		<link rel="stylesheet" href="./umbraco/backoffice/css/uui-css.css" />
+		<link rel="stylesheet" href="./umbraco/backoffice/css/light.css" />
 		<script src="./umbraco/backoffice/msw/index.js"></script>
 		<script type="module" src="index.ts"></script>
 	</head>
diff --git a/src/Umbraco.Web.UI.Client/package-lock.json b/src/Umbraco.Web.UI.Client/package-lock.json
index dec04c284af4..ed96d8d6052a 100644
--- a/src/Umbraco.Web.UI.Client/package-lock.json
+++ b/src/Umbraco.Web.UI.Client/package-lock.json
@@ -66,8 +66,8 @@
 				"web-component-analyzer": "^2.0.0"
 			},
 			"engines": {
-				"node": ">=22.17.1",
-				"npm": ">=10.9.2"
+				"node": ">=24.13",
+				"npm": ">=11"
 			}
 		},
 		"node_modules/@adobe/css-tools": {
@@ -3823,923 +3823,17 @@
 			"link": true
 		},
 		"node_modules/@umbraco-ui/uui": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui/-/uui-1.17.2.tgz",
-			"integrity": "sha512-Wpa69fKWUrMAlUGxJ03vytpYigbOapaenqF6et/Gp2OydAVmYr4rkSnJvkaEqMTSHZnVAGGzf4LDLLBAfkhTVg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-action-bar": "1.17.2",
-				"@umbraco-ui/uui-avatar": "1.17.2",
-				"@umbraco-ui/uui-avatar-group": "1.17.2",
-				"@umbraco-ui/uui-badge": "1.17.2",
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-boolean-input": "1.17.2",
-				"@umbraco-ui/uui-box": "1.17.2",
-				"@umbraco-ui/uui-breadcrumbs": "1.17.2",
-				"@umbraco-ui/uui-button": "1.17.2",
-				"@umbraco-ui/uui-button-copy-text": "1.17.2",
-				"@umbraco-ui/uui-button-group": "1.17.2",
-				"@umbraco-ui/uui-button-inline-create": "1.17.2",
-				"@umbraco-ui/uui-card": "1.17.2",
-				"@umbraco-ui/uui-card-block-type": "1.17.2",
-				"@umbraco-ui/uui-card-content-node": "1.17.2",
-				"@umbraco-ui/uui-card-media": "1.17.2",
-				"@umbraco-ui/uui-card-user": "1.17.2",
-				"@umbraco-ui/uui-caret": "1.17.2",
-				"@umbraco-ui/uui-checkbox": "1.17.2",
-				"@umbraco-ui/uui-color-area": "1.17.2",
-				"@umbraco-ui/uui-color-picker": "1.17.2",
-				"@umbraco-ui/uui-color-slider": "1.17.2",
-				"@umbraco-ui/uui-color-swatch": "1.17.2",
-				"@umbraco-ui/uui-color-swatches": "1.17.2",
-				"@umbraco-ui/uui-combobox": "1.17.2",
-				"@umbraco-ui/uui-combobox-list": "1.17.2",
-				"@umbraco-ui/uui-css": "1.17.2",
-				"@umbraco-ui/uui-dialog": "1.17.2",
-				"@umbraco-ui/uui-dialog-layout": "1.17.2",
-				"@umbraco-ui/uui-file-dropzone": "1.17.2",
-				"@umbraco-ui/uui-file-preview": "1.17.2",
-				"@umbraco-ui/uui-form": "1.17.2",
-				"@umbraco-ui/uui-form-layout-item": "1.17.2",
-				"@umbraco-ui/uui-form-validation-message": "1.17.2",
-				"@umbraco-ui/uui-icon": "1.17.2",
-				"@umbraco-ui/uui-icon-registry": "1.17.2",
-				"@umbraco-ui/uui-icon-registry-essential": "1.17.2",
-				"@umbraco-ui/uui-input": "1.17.2",
-				"@umbraco-ui/uui-input-file": "1.17.2",
-				"@umbraco-ui/uui-input-lock": "1.17.2",
-				"@umbraco-ui/uui-input-password": "1.17.2",
-				"@umbraco-ui/uui-keyboard-shortcut": "1.17.2",
-				"@umbraco-ui/uui-label": "1.17.2",
-				"@umbraco-ui/uui-loader": "1.17.2",
-				"@umbraco-ui/uui-loader-bar": "1.17.2",
-				"@umbraco-ui/uui-loader-circle": "1.17.2",
-				"@umbraco-ui/uui-menu-item": "1.17.2",
-				"@umbraco-ui/uui-modal": "1.17.2",
-				"@umbraco-ui/uui-pagination": "1.17.2",
-				"@umbraco-ui/uui-popover": "1.17.2",
-				"@umbraco-ui/uui-popover-container": "1.17.2",
-				"@umbraco-ui/uui-progress-bar": "1.17.2",
-				"@umbraco-ui/uui-radio": "1.17.2",
-				"@umbraco-ui/uui-range-slider": "1.17.2",
-				"@umbraco-ui/uui-ref": "1.17.2",
-				"@umbraco-ui/uui-ref-list": "1.17.2",
-				"@umbraco-ui/uui-ref-node": "1.17.2",
-				"@umbraco-ui/uui-ref-node-data-type": "1.17.2",
-				"@umbraco-ui/uui-ref-node-document-type": "1.17.2",
-				"@umbraco-ui/uui-ref-node-form": "1.17.2",
-				"@umbraco-ui/uui-ref-node-member": "1.17.2",
-				"@umbraco-ui/uui-ref-node-package": "1.17.2",
-				"@umbraco-ui/uui-ref-node-user": "1.17.2",
-				"@umbraco-ui/uui-scroll-container": "1.17.2",
-				"@umbraco-ui/uui-select": "1.17.2",
-				"@umbraco-ui/uui-slider": "1.17.2",
-				"@umbraco-ui/uui-symbol-expand": "1.17.2",
-				"@umbraco-ui/uui-symbol-file": "1.17.2",
-				"@umbraco-ui/uui-symbol-file-dropzone": "1.17.2",
-				"@umbraco-ui/uui-symbol-file-thumbnail": "1.17.2",
-				"@umbraco-ui/uui-symbol-folder": "1.17.2",
-				"@umbraco-ui/uui-symbol-lock": "1.17.2",
-				"@umbraco-ui/uui-symbol-more": "1.17.2",
-				"@umbraco-ui/uui-symbol-sort": "1.17.2",
-				"@umbraco-ui/uui-table": "1.17.2",
-				"@umbraco-ui/uui-tabs": "1.17.2",
-				"@umbraco-ui/uui-tag": "1.17.2",
-				"@umbraco-ui/uui-textarea": "1.17.2",
-				"@umbraco-ui/uui-toast-notification": "1.17.2",
-				"@umbraco-ui/uui-toast-notification-container": "1.17.2",
-				"@umbraco-ui/uui-toast-notification-layout": "1.17.2",
-				"@umbraco-ui/uui-toggle": "1.17.2",
-				"@umbraco-ui/uui-visually-hidden": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-action-bar": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-action-bar/-/uui-action-bar-1.17.2.tgz",
-			"integrity": "sha512-58FCYYVcr/kDx3vCtBNKMUD/Wm9hLSRJ+Vcz7B+PB+Ksj5mHNXtfxEqwZkh8E1CXosrYVvd9IrGjjIo9keQx5w==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-button-group": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-avatar": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-avatar/-/uui-avatar-1.17.2.tgz",
-			"integrity": "sha512-9tQ7YvHBfQhy30yI0c/+gAGOMGRBlAj06nalAlOeeRE96Gs+qLD4xFfmhdl4+A4QJNube/VvujTOShrlACdfqA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-avatar-group": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-avatar-group/-/uui-avatar-group-1.17.2.tgz",
-			"integrity": "sha512-It0ml/h4PWm/Uoy7VdESJEV/xjvEJnC5dQjZlG6I6x+HmpejbJs8/EPNiWiksNff7A6yZ0zHNJOoZjJPTEcGmQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-avatar": "1.17.2",
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-badge": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-badge/-/uui-badge-1.17.2.tgz",
-			"integrity": "sha512-JLbzuWk7lsN2e3wLPxD4+gGTAoufIo+cAjIR+3+UAPY36PXwuUulnypuATLElqL5PPBQssjQmBF/K0o83V2HjQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-base": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-base/-/uui-base-1.17.2.tgz",
-			"integrity": "sha512-UZkHUY2vdc61t9uq8ey2o4Qpb2aAAQC5HoeBqUu/lEpaWRezHk7QoFIeQrzo3QC2xUa6lSqmSuTYQRWUdFaH2Q==",
-			"license": "MIT",
-			"peerDependencies": {
-				"lit": ">=2.8.0"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-boolean-input": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-boolean-input/-/uui-boolean-input-1.17.2.tgz",
-			"integrity": "sha512-34gdbpSCQRUeLTzh0N+w4GazRbqR4bWAvi5HQe5N/qKrI/5ziQEVQNRaintmxTZ3S6WxxAbF5yaF60UbCW75iA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-box": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-box/-/uui-box-1.17.2.tgz",
-			"integrity": "sha512-tXBSnb1Gmxub7772SqQvHngbmMkrPzfZ6TorZkNLJlddlNgYJmpoGeFZKGVaJpwCOR+W3O7LcT/juOv+sPvv4A==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-css": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-breadcrumbs": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-breadcrumbs/-/uui-breadcrumbs-1.17.2.tgz",
-			"integrity": "sha512-KRFyw7c0OS12zSPFN8A1uCFPdBEshN0SWHMXcZsP4nswjYkj6sJYe6sWUjDETgmgtf9zYK6SzUjI8gyZoFuLFQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-responsive-container": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-button": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-button/-/uui-button-1.17.2.tgz",
-			"integrity": "sha512-F3NO89b3vHOOhWrfM170Z383HsYf9Nji1LxZAedXtAyNzXjIGRKQH5cbiDJBZ8r9J51dVOl0glr23Di4SHiNsA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-icon-registry-essential": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-button-copy-text": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-button-copy-text/-/uui-button-copy-text-1.17.2.tgz",
-			"integrity": "sha512-vbaykS2iQM5Lj1oJpSrkfMErYgeR/hxIsYdpGyl41Xc0XZbQxA6ZhhXuOwKnkALnJX3rr0myhSfzk+xBA1nZ6Q==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-button": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-button-group": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-button-group/-/uui-button-group-1.17.2.tgz",
-			"integrity": "sha512-XvSN8wngvTCPKgIRei1glKiMhBiATFpzNLuc1nJFnDoljlrehzbViwUNtGv+dtxe5XmdEp1cKQB5LW4PesQrZw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-button-inline-create": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-button-inline-create/-/uui-button-inline-create-1.17.2.tgz",
-			"integrity": "sha512-NLzwh0mMOIZSe3mj5bHy1vobSqU7VW/G1ixswngwj2FSBsIxLOZY32pECvXPA8dGfazH2Xl5dIIemyrh8vN4xw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-card": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-card/-/uui-card-1.17.2.tgz",
-			"integrity": "sha512-8WpXK0MU6ycSidpG41wTxWrn8iHR9A/xWZgx2wuol3qF73wakRVR7IdoWxsTAtj7uVg2xp6q19ABZLML+BUG9g==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-checkbox": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-card-block-type": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-card-block-type/-/uui-card-block-type-1.17.2.tgz",
-			"integrity": "sha512-GPuUNj1rjy+HavtzkvF5LEDvYmhN5W7DTRB+5WSpUmX6cyNP/J+LJfx6q0FxOD1DtmLl3/lTLhZxfNe/E2QKsA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-card": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-card-content-node": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-card-content-node/-/uui-card-content-node-1.17.2.tgz",
-			"integrity": "sha512-21gwLrvS/A3CuYo0fdD5CLZEil+LehqNk0OY+OwYu07n72O0lQK97BTuwqrDI8IeRhm+xtAof45RiWPBu4ydww==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-card": "1.17.2",
-				"@umbraco-ui/uui-icon": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-card-media": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-card-media/-/uui-card-media-1.17.2.tgz",
-			"integrity": "sha512-pOs9DMkdFH00OZlYMfODCgA+BQA8EkTutkTdx1YiucmJUfRt+Lt6pnZjHn+BW0vuo1S69Bn4qXP+1XzbwCREqw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-card": "1.17.2",
-				"@umbraco-ui/uui-symbol-file": "1.17.2",
-				"@umbraco-ui/uui-symbol-folder": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-card-user": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-card-user/-/uui-card-user-1.17.2.tgz",
-			"integrity": "sha512-jnqIMQ66pV1QDMxkDeljbnm+QTSpqyuTu4UIwWtEi2F2z4yIidZ7E5Ii9T1Z2lOW9hxKBuR4DG0LrxIg0ZeniA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-avatar": "1.17.2",
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-card": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-caret": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-caret/-/uui-caret-1.17.2.tgz",
-			"integrity": "sha512-8nDsGmr/K2uYpdKMImofvK9rYvdfLqppLOvXEE2JwzEsFT04LACm14rvTUsYHGKAAOYwCosb/NDm+bPCagJVvA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-checkbox": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-checkbox/-/uui-checkbox-1.17.2.tgz",
-			"integrity": "sha512-9NTKAdaqMHVnOyX7ya8pJ4hEyIh1p2DciOJCpL8Jy73K2NqsHl5VQLs7YR7LnijlAoJsOXKES0LxcYgfOzDOpA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-boolean-input": "1.17.2",
-				"@umbraco-ui/uui-icon-registry-essential": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-color-area": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-color-area/-/uui-color-area-1.17.2.tgz",
-			"integrity": "sha512-4NWt9OoyG81JvifcsrBufhOeJL1CBkmEeSIRms3Rokbsg6imeEJ/e6Ga4AJFauAhsroloxirf7QBfUUQ+lEueg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"colord": "^2.9.3"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-color-picker": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-color-picker/-/uui-color-picker-1.17.2.tgz",
-			"integrity": "sha512-SOpJtZb11gm33WZfRltmoSmRgw7JDsG14GqbBwi4KL556+GLzeNMRPswU4hDCb7e69A1hK8+oBoMIVQwXPB6vw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-popover-container": "1.17.2",
-				"colord": "^2.9.3"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-color-slider": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-color-slider/-/uui-color-slider-1.17.2.tgz",
-			"integrity": "sha512-sCygVWQHOw4eOxTl3EpN1/3BF9wLnnBostEWG8Om6EFRoXCb9DMBvh/kTfkF6ZoUIGxPFPAD1hpXF/ANtUka2Q==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-color-swatch": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-color-swatch/-/uui-color-swatch-1.17.2.tgz",
-			"integrity": "sha512-hMAUzXDCNR2H4yPZDJmUig4kQt9xL/gH7ghcazYxeY7vuLLnGucxljTfTiZISqdjeQpheSt807gz9XnWDLY9Ng==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-icon-registry-essential": "1.17.2",
-				"colord": "^2.9.3"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-color-swatches": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-color-swatches/-/uui-color-swatches-1.17.2.tgz",
-			"integrity": "sha512-M0flkhmZvcx2oYcn5ffK2z/ByKMEjALd4fy0BQ4Yzz4OerWFliojkXfv1Dc27Lyzl+UKJFf7LK61UY/MA2Z42Q==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-color-swatch": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-combobox": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-combobox/-/uui-combobox-1.17.2.tgz",
-			"integrity": "sha512-X3PqQzpkvj8mfbjb/ntLgLPIWTy6Mvw2lIyPcOCGN6eg5CAai51qZjt/S9KSg5c//UQings3i//G/ycyIBKBEg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-button": "1.17.2",
-				"@umbraco-ui/uui-combobox-list": "1.17.2",
-				"@umbraco-ui/uui-icon": "1.17.2",
-				"@umbraco-ui/uui-popover-container": "1.17.2",
-				"@umbraco-ui/uui-scroll-container": "1.17.2",
-				"@umbraco-ui/uui-symbol-expand": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-combobox-list": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-combobox-list/-/uui-combobox-list-1.17.2.tgz",
-			"integrity": "sha512-EPVQfG692sS9XT+qn6QU4dUbGTgQzneF4sHcmbm6gyHfutW3pv0xCa43RspoXK8iMjNdrHEqZqW1bpSWIhp3fA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-css": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-css/-/uui-css-1.17.2.tgz",
-			"integrity": "sha512-+g+Za0i2ZUZTf9C5GOmJ6olJxH3J181GIB79mg7soAUG/ofMTOw0uKR34sG9SUXG2+qoenzWoF9B5qUjydJOeQ==",
-			"license": "MIT",
-			"peerDependencies": {
-				"lit": ">=2.8.0"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-dialog": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-dialog/-/uui-dialog-1.17.2.tgz",
-			"integrity": "sha512-6f89YWRvYUHcLLf5yZ5UXT36bPuRTBRt6AqCREy2NTox1M0e2fU4+T61UrEy8XjcF25+8Ylc+ETb7KCHeUb1FA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-css": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-dialog-layout": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-dialog-layout/-/uui-dialog-layout-1.17.2.tgz",
-			"integrity": "sha512-sBeFz6UZUtArP9/bnykuZVT1S4oYK9JjIOm36Z0Wurw893aPAHiNCq9hrCaZF8xmS+ZLrqSmkNhZ22slKWkw6Q==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-file-dropzone": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-file-dropzone/-/uui-file-dropzone-1.17.2.tgz",
-			"integrity": "sha512-1JnURFHBHpO/QCEaMXJOj1xj1ttOPjn7twxOlZeJgpZoKDepqxRCW2UX9vqwop+ge3LWoMMvSTxa6GNHBs34gA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-symbol-file-dropzone": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-file-preview": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-file-preview/-/uui-file-preview-1.17.2.tgz",
-			"integrity": "sha512-L+w5mMIcgwNlWA6/SAWoU9bpEbzEB/reVWALWOAScv1Lvqo/HmjjxHMclFJzm+6DSM3euH53X2zOHmAp1oUnOA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-symbol-file": "1.17.2",
-				"@umbraco-ui/uui-symbol-file-thumbnail": "1.17.2",
-				"@umbraco-ui/uui-symbol-folder": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-form": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-form/-/uui-form-1.17.2.tgz",
-			"integrity": "sha512-39ynzYgPdhpDSyVxpBJBDPrRmGKfnhcHVrMTcv5ITUnmsHizqd4tK5+gdf5tcHXrAxb+AWHEufwjjNcRHdl/Ww==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-form-layout-item": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-form-layout-item/-/uui-form-layout-item-1.17.2.tgz",
-			"integrity": "sha512-FLDd+Y5x/6L8cHAPzicX/e4mxH/tx2DBWuzXV4MeNp8eRS132xCBM9laI+1/dnBjCzYzJuVd8ibmFO0+Yjf8Uw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-form-validation-message": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-form-validation-message": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-form-validation-message/-/uui-form-validation-message-1.17.2.tgz",
-			"integrity": "sha512-AWI9WC7wZW7qgrZ1EUnzCt40KdB1iiJBPwUnyffm4L3MsGyUVEQYYO96v/y04PGFr6DUlcDlAerhSqcsaJK7Kw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-icon": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-icon/-/uui-icon-1.17.2.tgz",
-			"integrity": "sha512-7WmGW3nn7IeL5nMZtIYaSWaV0AeBoE90rfAqjbK/fHzyDtgM1gsokXhCtEQH9VLnjFfs02bXF+Xlw+ZEP3+p5A==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-icon-registry": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-icon-registry/-/uui-icon-registry-1.17.2.tgz",
-			"integrity": "sha512-P5ypiDGswu0uPhyVcltuFHLkVax9DURUgz2jgsuNDkLJh4BW34TFTHu7c7XKVRzVMIb7356SxO8B+q6fYEPNqA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-icon": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-icon-registry-essential": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-icon-registry-essential/-/uui-icon-registry-essential-1.17.2.tgz",
-			"integrity": "sha512-vfumKb+H6bT1tTMKOHK/rZW4QDBxzANzAqvAqpeB7n0EEd5j+82tSv15DDZDlyXHvMNUnoBrI+zNpCYsDbNV5Q==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-icon-registry": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-input": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-input/-/uui-input-1.17.2.tgz",
-			"integrity": "sha512-8aoM58rkLEYdQljWHBA8hgwEqnjeVXzFfMdO+QuwgLpKEBZij/33iWBl2j/IGmxByiFcxSvsbzEFhXHNRlU4Jg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-input-file": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-input-file/-/uui-input-file-1.17.2.tgz",
-			"integrity": "sha512-bWwp6KkMDuMvIjmRh9WOXBdVyaEdcCyvdqBYss+BrXEeHF+Qs9SMHK4giLGAosYIWxzctmT9tUZfUpuJu8QP0w==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-action-bar": "1.17.2",
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-button": "1.17.2",
-				"@umbraco-ui/uui-file-dropzone": "1.17.2",
-				"@umbraco-ui/uui-icon": "1.17.2",
-				"@umbraco-ui/uui-icon-registry-essential": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-input-lock": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-input-lock/-/uui-input-lock-1.17.2.tgz",
-			"integrity": "sha512-Vu6TViMQuERTqx5kd518aujwrtztxbErHqAw1VNl6aT1q4GoADLtVyxnFYMhtg6mokUJL4ZxTxMuiAKVLjJM9Q==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-button": "1.17.2",
-				"@umbraco-ui/uui-icon": "1.17.2",
-				"@umbraco-ui/uui-input": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-input-password": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-input-password/-/uui-input-password-1.17.2.tgz",
-			"integrity": "sha512-a7hLURjTwNpuqepeBAWOGyKmvuy9dPXs2YdxakaoUsia486gjerIZOKv29vQ83Uw5EivdvYZMuFGM4TngQZ26g==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-icon-registry-essential": "1.17.2",
-				"@umbraco-ui/uui-input": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-keyboard-shortcut": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-keyboard-shortcut/-/uui-keyboard-shortcut-1.17.2.tgz",
-			"integrity": "sha512-2XXU9p80iGJVsHvIDA4u/IsRTD1psW5yEmWZbUJI0nouhGfoBGjF6mgo2AYEVczrP90JBvWJhhunCe1JfPK9WQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-label": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-label/-/uui-label-1.17.2.tgz",
-			"integrity": "sha512-xbvmKU2zGNaIo1Zn7cOy6EmidxzFYoihsEkbOrMBItbebhZcZc+MUHuEFr+brgMHowk0CtUJnITjpSsow/4BUA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-loader": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-loader/-/uui-loader-1.17.2.tgz",
-			"integrity": "sha512-wnR47k7zbDG4upQmucTuaNyyFR9VKVoBiGLTGTITNvK66G+EpwL96xwd3YqbJx4oRXQEkCyorlbE8oxY2B9Xig==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-loader-bar": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-loader-bar/-/uui-loader-bar-1.17.2.tgz",
-			"integrity": "sha512-KHe1W3pHaJ5SX+D1TcLOYti5Z+RuVd5o0Wm4XONvWN7DZ/cs1E8pO0mvgJYLZbZv989u9RwhH4cuOCxTByt4ew==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-loader-circle": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-loader-circle/-/uui-loader-circle-1.17.2.tgz",
-			"integrity": "sha512-pYXvXEhm+oNWDNc2QKNDK9nILAPnegyTkQEdhBumF5RqISCZT0OXufhP8//Ez7Ao/c84I0Jv/jVNqgmDIxg0wg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-menu-item": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-menu-item/-/uui-menu-item-1.17.2.tgz",
-			"integrity": "sha512-aDAp61Z/3/1qQN34phkekYHH+IpCldNp26VF4PZBb7YlpxYfbEbO/xKqxkRQYvrEeq1TNpDQF8vhmbJn0BdmaA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-loader-bar": "1.17.2",
-				"@umbraco-ui/uui-symbol-expand": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-modal": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-modal/-/uui-modal-1.17.2.tgz",
-			"integrity": "sha512-IFrpRuFrouYo8DqrK1DyrGWkmHbf8sP5OQjCqYfmZ15AwqPt791h4uwTponrjJVOwFwy2sq3mZPAR7ob/V/6DA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-pagination": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-pagination/-/uui-pagination-1.17.2.tgz",
-			"integrity": "sha512-ECWL/9p5IDBf8EKES9pG8QL+5hNNagmtE+3hCZH2x+D3yW28fcMh8SW5QtBgfebBNXdZAp4lrxcTtUyFA6By+g==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-button": "1.17.2",
-				"@umbraco-ui/uui-button-group": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-popover": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-popover/-/uui-popover-1.17.2.tgz",
-			"integrity": "sha512-Pqh7k+ZpEGGMdpRbNO6+6p9ggZ/wtZs9MyylB6/56PLlIepVqhGBqlJbJ6+z4Ph4S752btMmqz04GdJ09yaZuA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-popover-container": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-popover-container/-/uui-popover-container-1.17.2.tgz",
-			"integrity": "sha512-lCzQFUo3QESYbKkk69KJMC5cmJ4VS3hEPdSRATzBqEDtzj/h6aEdrww1EOAOOLCw+JgNd0wKS/+sp3RCmiZxeg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-progress-bar": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-progress-bar/-/uui-progress-bar-1.17.2.tgz",
-			"integrity": "sha512-I/T0K4l9QcWJGSOI4G7Zr4uMz/UjgM4nA7ebjDc2cgY5hLcefknFS5LSGWjPxTe+R9OIFFkFXLvQqlFZnH2AcQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-radio": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-radio/-/uui-radio-1.17.2.tgz",
-			"integrity": "sha512-iDvaEUltTAAwqRYY/8bIRyfN2j9vGc3CpZlWNe5nC2QOD+tPVEq5MWyg3N3Gbx6K9bkg+DrIAblk2Mc8YFEHAg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-range-slider": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-range-slider/-/uui-range-slider-1.17.2.tgz",
-			"integrity": "sha512-mjgxoHQnkIKrYv2I1mjESgSy8yPZOSHoFURoeh9fc3G0bnkoTbNwLMKMWL3NSQObHo+TpK6djSaiXLB1vIAwJA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-ref": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-ref/-/uui-ref-1.17.2.tgz",
-			"integrity": "sha512-SWyS/sduAw8vmesw0Sm7jsblhZ7i9vckOAzCQs2Hrbtssgq1EZ0PkkICS2Vg3rVnR0HSYt8T2s7Fy7yjK4MYHQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-ref-list": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-ref-list/-/uui-ref-list-1.17.2.tgz",
-			"integrity": "sha512-LzKcN94JSpbH0YmpBj9fl58WdwFeGbovFhLBInUcLOX8WqK0E+lNdBLRya7l8KYIKmhQKE3TUbqiN6Qcwhr2mA==",
+			"version": "2.0.0-alpha.1",
+			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui/-/uui-2.0.0-alpha.1.tgz",
+			"integrity": "sha512-WcBhB0t243yxTTVzdLJn+JAeGxWp7fyqUoctzhFDunvUvRu3dZk7uZF+eed+nZFb/tivZZ4pRBJ2FqcPXwBLNg==",
 			"license": "MIT",
 			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-ref-node": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-ref-node/-/uui-ref-node-1.17.2.tgz",
-			"integrity": "sha512-C6fqnEDYlGlqF3gEQFPy8908LcZLzPqhVHC1p6AXXNkTPnnKqSAPxRPKRUk7XUoQSYFDXfCzFnlyKdlpWSIJBQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-icon": "1.17.2",
-				"@umbraco-ui/uui-ref": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-ref-node-data-type": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-ref-node-data-type/-/uui-ref-node-data-type-1.17.2.tgz",
-			"integrity": "sha512-nEEKv8TYjueZprnfFg9sW1u/Y3Z8X+IqGPWRg0Hx+gLLKmOPHbvlYUIB8M4Q4G61XlcY8dfw+TDZ8kxTekmEWA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-ref-node": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-ref-node-document-type": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-ref-node-document-type/-/uui-ref-node-document-type-1.17.2.tgz",
-			"integrity": "sha512-w+qe2g9FDUTHLzRStffDOoudHUeWw+RXgoOLtI8f5xktbuKDcpz6qiIOIvTO9ipfy9vpbU/WiUr7OSBVdxGSaQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-ref-node": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-ref-node-form": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-ref-node-form/-/uui-ref-node-form-1.17.2.tgz",
-			"integrity": "sha512-056oxK3ffKIERFfYgYG+Ies4S75TPEdME1WXYYG6p9QzfZ06Y0VaNCQbzoHwS8CcbtO5/m2C3BXB6b0l26lDkg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-ref-node": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-ref-node-member": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-ref-node-member/-/uui-ref-node-member-1.17.2.tgz",
-			"integrity": "sha512-oeWQHu7u1/xK9IOnm5YMceLPzfGsuIsYyU+UJRJkwIiWYT155gosdGoxCz/AkMr58NBT223ES1UKFCZJaRFTGg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-ref-node": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-ref-node-package": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-ref-node-package/-/uui-ref-node-package-1.17.2.tgz",
-			"integrity": "sha512-3hWJvvOCLYOZNt0fMdH8atwQrrPF6eM3ftZcxPCch8/cW3AQ5jWIpYnP/s4hRhNFCWKkKW7Y5l/vBbT2LKEtUA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-ref-node": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-ref-node-user": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-ref-node-user/-/uui-ref-node-user-1.17.2.tgz",
-			"integrity": "sha512-9KdVhHe10UXN3RnZJ5pMT1WBpbKZxdOREpSq0tjN+o1EYEqnSw9EM5RrCVZx/OsljJzgzFNZRkhEr+zlmsr30A==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-ref-node": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-responsive-container": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-responsive-container/-/uui-responsive-container-1.17.2.tgz",
-			"integrity": "sha512-eH4x9JpJyw7/IPyqAE6EpNq4jp7OlMkHlirnAMJZsp0v6Ou/NhuIossFaxla/OMX4PtulGL1WsoeIX3D4B7fQQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-button": "1.17.2",
-				"@umbraco-ui/uui-button-group": "1.17.2",
-				"@umbraco-ui/uui-popover-container": "1.17.2",
-				"@umbraco-ui/uui-symbol-more": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-scroll-container": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-scroll-container/-/uui-scroll-container-1.17.2.tgz",
-			"integrity": "sha512-ZdpJINTnguUIGFkjrm/6MPl2KrAai3UrrVYBOjx2CBvYxnfAsu/zicQ54kIoqsoYXDnIx/9xCKLodKLlHhz6LA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-select": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-select/-/uui-select-1.17.2.tgz",
-			"integrity": "sha512-IhocB11XsXFDI5hcEEXJJSeUfYZLKwqBWMh2TemFKEsafzFkGvmOEqppxrZD1J3wcWZAXODoSLoURcKIafQqLA==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-slider": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-slider/-/uui-slider-1.17.2.tgz",
-			"integrity": "sha512-ewO5NYZptQUMJRkO1MFH5RdwtjFEpaVtLBbBAfmV7CevY+kY7q6KeITlBZW8J8alMM3lNF8HGg0ccTg0gJ7I8g==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-symbol-expand": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-symbol-expand/-/uui-symbol-expand-1.17.2.tgz",
-			"integrity": "sha512-qOee3XhHOu7QsbBUp1TOGHBpiE+oj+BY8Eh/lC8cDkwGc9yTndM4SU+YX/HN1qcLfIvqiAu3TnX53/KOjyKdzw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-symbol-file": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-symbol-file/-/uui-symbol-file-1.17.2.tgz",
-			"integrity": "sha512-flDs3M9h+uAp8WJPXLLHNR9nLqDLU1TRTyCS3L7OYJz81/WuAwlvt3okezTJEC5dgtNH4guoIXJbHsY7XMVYNw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-symbol-file-dropzone": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-symbol-file-dropzone/-/uui-symbol-file-dropzone-1.17.2.tgz",
-			"integrity": "sha512-WwG5o5Gm1j3UKUYMCQW3PM2sIUHOecmxq1FQETyhUoPFJKRTgsP2J261pWk/2S+VbEEtKB1v0MlZWSdz60D3Ww==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-symbol-file-thumbnail": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-symbol-file-thumbnail/-/uui-symbol-file-thumbnail-1.17.2.tgz",
-			"integrity": "sha512-IF4fcz4wGFy5qpi0hE5sWyTl5gnw0wrnDaCZapi0Xfie6le6m7CgJCz9dp8CWPQFl01UDWr/1eR6C0XEO0FlNQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-symbol-folder": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-symbol-folder/-/uui-symbol-folder-1.17.2.tgz",
-			"integrity": "sha512-08ma38W6h805EiHELsGojS+Q3CoBoVKoR5yIY5f1/Pb/a2etCcTVRmKQuAlUD1vc9sSBdJBsoNOeczZPy7xCYQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-symbol-lock": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-symbol-lock/-/uui-symbol-lock-1.17.2.tgz",
-			"integrity": "sha512-DJkcQs519aSlezLMxTl/hf0gMAg1GVA6QiQhX6hOEARV4C6/TUpwDpXK/j9/5M9mtqjgPfDG97+SJi0iVgcsew==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-symbol-more": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-symbol-more/-/uui-symbol-more-1.17.2.tgz",
-			"integrity": "sha512-7F49+dHg5l2a4Ftv0aZAkirZZlkhKDLjyupAX+/FvSiv+cJbmKwgmmre4n2fShWkxeJ4RKh/AT1MR1l8GzxH4g==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-symbol-sort": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-symbol-sort/-/uui-symbol-sort-1.17.2.tgz",
-			"integrity": "sha512-7k9ckDBrBf5O3UNveAIL2KIzXSZq8CE3C3HTn2k0EPjK0pZZXGYCc0u8fU8JuxNxX8GA3N8IeVOpM3OaHKa8vg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-table": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-table/-/uui-table-1.17.2.tgz",
-			"integrity": "sha512-pjVK3gZ00ucXzsmB32EaxRXrxXbFSP+trcZm3qiFcD6cK2wLx6HMtcVxHgHGQR+OYJ/0v7Q7KvIBepC7gdA7fQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-tabs": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-tabs/-/uui-tabs-1.17.2.tgz",
-			"integrity": "sha512-5GjxdMTYbAsDcIhJqAfsdypkE7yHvYXrsSc6vTDldB3mn9yA3BxpgzAijWnjptugMhG/a9L7myODp3kt4k4Z/w==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-button": "1.17.2",
-				"@umbraco-ui/uui-popover-container": "1.17.2",
-				"@umbraco-ui/uui-symbol-more": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-tag": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-tag/-/uui-tag-1.17.2.tgz",
-			"integrity": "sha512-LCwC3ZrMu1A624VZz1oNGzd1SQ5UImEH+hpptb0BunEOQ3JkOOiwNKJny/Sfc/Z+GAWFnrOiRxNQPBzgAWXFJw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-textarea": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-textarea/-/uui-textarea-1.17.2.tgz",
-			"integrity": "sha512-6ZdTsIcSAPOT7K+YxLowEmQpRu330Vawqp7vuegC7VgmqFZerIGJZhPcJbLnUJJ5co8IH2IWj5DYyMLOx3Eqaw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-toast-notification": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-toast-notification/-/uui-toast-notification-1.17.2.tgz",
-			"integrity": "sha512-bu5JTbgiJje6b5FTXNNjefaXhDZNiBeUaUgGDlG6c8q7Q/fdm5fqwcaOKQog2hc0dZn+thqeVHRZwFBrvsgeYg==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-button": "1.17.2",
-				"@umbraco-ui/uui-css": "1.17.2",
-				"@umbraco-ui/uui-icon": "1.17.2",
-				"@umbraco-ui/uui-icon-registry-essential": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-toast-notification-container": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-toast-notification-container/-/uui-toast-notification-container-1.17.2.tgz",
-			"integrity": "sha512-6wrHbpd1C+vHJT4Y1rVh09+dPpHFpQslcVvrh9Jk4U2QJiAph6UURj6QbxKutQrYRH6snq2Nue4vHq++LYNS8w==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-toast-notification": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-toast-notification-layout": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-toast-notification-layout/-/uui-toast-notification-layout-1.17.2.tgz",
-			"integrity": "sha512-9XSmjrwXzy6dc08f36bqcUaPUkKDApjlwF+CpjUgwrLtdGVjOrixNEQnj8oFSxQEas01VzO0rhH+mYzYNC6fwQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-css": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-toggle": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-toggle/-/uui-toggle-1.17.2.tgz",
-			"integrity": "sha512-brc2pKPd7j5TKOFKdbkRaZQah03XYGAPlO7j3IkdM2AXQRc0BaVseD/xHb8FeENzTYLL4XL7rseYkn16GbBhFQ==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2",
-				"@umbraco-ui/uui-boolean-input": "1.17.2"
-			}
-		},
-		"node_modules/@umbraco-ui/uui-visually-hidden": {
-			"version": "1.17.2",
-			"resolved": "https://registry.npmjs.org/@umbraco-ui/uui-visually-hidden/-/uui-visually-hidden-1.17.2.tgz",
-			"integrity": "sha512-OxWccGa7VGjr1nvK0f6F6+DcqVYaW8QN/83Sg81eaKSg88Td15un3tws9w0BPjoaMYWFbvZXk3uofDs1V7vDrw==",
-			"license": "MIT",
-			"dependencies": {
-				"@umbraco-ui/uui-base": "1.17.2"
+				"culori": "^4.0.2",
+				"lit": "^3.0.0"
+			},
+			"engines": {
+				"node": ">=24.13",
+				"npm": ">=11"
 			}
 		},
 		"node_modules/@vitest/expect": {
@@ -6389,6 +5483,7 @@
 			"version": "2.9.3",
 			"resolved": "https://registry.npmjs.org/colord/-/colord-2.9.3.tgz",
 			"integrity": "sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==",
+			"dev": true,
 			"license": "MIT"
 		},
 		"node_modules/command-line-args": {
@@ -6787,6 +5882,15 @@
 			"dev": true,
 			"license": "CC0-1.0"
 		},
+		"node_modules/culori": {
+			"version": "4.0.2",
+			"resolved": "https://registry.npmjs.org/culori/-/culori-4.0.2.tgz",
+			"integrity": "sha512-1+BhOB8ahCn4O0cep0Sh2l9KCOfOdY+BXJnKMHFFzDEouSr/el18QwXEMRlOj9UY5nCeA8UN3a/82rUWRBeyBw==",
+			"license": "MIT",
+			"engines": {
+				"node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+			}
+		},
 		"node_modules/data-uri-to-buffer": {
 			"version": "6.0.2",
 			"resolved": "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz",
@@ -17539,8 +16643,7 @@
 		"src/external/uui": {
 			"name": "@umbraco-backoffice/uui",
 			"dependencies": {
-				"@umbraco-ui/uui": "^1.17.2",
-				"@umbraco-ui/uui-css": "^1.17.1"
+				"@umbraco-ui/uui": "^2.0.0-alpha.1"
 			}
 		},
 		"src/libs/class-api": {
diff --git a/src/Umbraco.Web.UI.Client/package.json b/src/Umbraco.Web.UI.Client/package.json
index 2d9fb3c415c3..b2669cb18eb1 100644
--- a/src/Umbraco.Web.UI.Client/package.json
+++ b/src/Umbraco.Web.UI.Client/package.json
@@ -225,8 +225,8 @@
 		"generate:ui-api-docs": "npm run generate:check-const-test && typedoc --options typedoc.config.js"
 	},
 	"engines": {
-		"node": ">=22.17.1",
-		"npm": ">=10.9.2"
+		"node": ">=24.13",
+		"npm": ">=11"
 	},
 	"dependencies": {
 		"element-internals-polyfill": "^3.0.2"
@@ -295,4 +295,4 @@
 		"access": "public",
 		"registry": "https://registry.npmjs.org/"
 	}
-}
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web.UI.Client/src/apps/installer/database/installer-database.element.ts b/src/Umbraco.Web.UI.Client/src/apps/installer/database/installer-database.element.ts
index 428d1729407a..5c3b701639b1 100644
--- a/src/Umbraco.Web.UI.Client/src/apps/installer/database/installer-database.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/apps/installer/database/installer-database.element.ts
@@ -1,7 +1,7 @@
 import type { UmbInstallerContext } from '../installer.context.js';
 import { UMB_INSTALLER_CONTEXT } from '../installer.context.js';
 
-import type { UUIButtonElement } from '@umbraco-cms/backoffice/external/uui';
+import type { UUIButtonElement, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 import type { CSSResultGroup } from '@umbraco-cms/backoffice/external/lit';
 import { css, html, nothing, customElement, property, query, state } from '@umbraco-cms/backoffice/external/lit';
 import type {
@@ -21,7 +21,7 @@ export class UmbInstallerDatabaseElement extends UmbLitElement {
 	public databaseFormData!: DatabaseInstallRequestModel;
 
 	@state()
-	private _options: Option[] = [];
+	private _options: UUISelectOption[] = [];
 
 	@state()
 	private _databases: DatabaseSettingsPresentationModel[] = [];
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/ar.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/ar.ts
index 7b53ac7f630f..c422ad089c3c 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/ar.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/ar.ts
@@ -1776,7 +1776,7 @@ export default {
 		createDate: 'تاريخ إنشاء المستخدم',
 		changePassword: 'تغيير كلمة المرور',
 		changePhoto: 'تغيير الصورة',
-		configureMfa: 'تكوين MFA',
+		configureMfa: 'تكوين 2FA',
 		emailRequired: 'مطلوب - أدخل عنوان بريد إلكتروني لهذا المستخدم',
 		emailDescription: (usernameIsEmail) => {
 			return usernameIsEmail
@@ -2102,7 +2102,8 @@ export default {
 		openBackofficeSearch: 'فتح بحث المكتب الخلفي',
 		openCloseBackofficeHelp: 'فتح/إغلاق مساعدة المكتب الخلفي',
 		openCloseBackofficeProfileOptions: 'فتح/إغلاق خيارات ملفك الشخصي',
-		profileOptions: 'خيارات الملف الشخصي',
+		profileOptions: 'ملف المستخدم الشخصي لـ %0% (%1%)',
+		profileOptionsDefault: 'ملف المستخدم الشخصي',
 		assignDomainDescription: 'إعداد الثقافة وأسماء النطاقات لـ %0%',
 		createDescription: 'إنشاء عقدة جديدة تحت %0%',
 		protectDescription: 'إعداد قيود الوصول على %0%',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/bs.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/bs.ts
index a768b8f9cc9c..33f93645299c 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/bs.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/bs.ts
@@ -1984,7 +1984,8 @@ export default {
 		openBackofficeSearch: 'Otvorite backoffice pretragu',
 		openCloseBackofficeHelp: 'Otvori/Zatvori pomoć za backoffice',
 		openCloseBackofficeProfileOptions: 'Opcije otvaranja/zatvaranja profila',
-		profileOptions: 'Opcije profila',
+		profileOptions: 'Profil korisnika za %0% (%1%)',
+		profileOptionsDefault: 'Profil korisnika',
 		assignDomainDescription: 'Postavite kulturu i imena hostova za %0%',
 		createDescription: 'Kreirajte novi čvor ispod %0%',
 		protectDescription: 'Postavite ograničenja pristupa uključena %0%',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/cs.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/cs.ts
index 089328a8c67b..4784c3521f34 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/cs.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/cs.ts
@@ -1809,7 +1809,8 @@ export default {
 		openBackofficeSearch: 'Otevřít hledání v backoffice',
 		openCloseBackofficeHelp: 'Otevřít/zavřít nápovědu backoffice',
 		openCloseBackofficeProfileOptions: 'Otevřít/zavřít možnosti vašeho profilu',
-		profileOptions: 'Opcije profila',
+		profileOptions: 'Profil uživatele pro %0% (%1%)',
+		profileOptionsDefault: 'Profil uživatele',
 		openContextMenu: 'Otevřít kontextové menu pro',
 		currentLanguage: 'Aktuální jazyk',
 		switchLanguage: 'Přepnout jazyk na',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/cy.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/cy.ts
index a9b6f950ff4f..9f8797b75d8b 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/cy.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/cy.ts
@@ -2166,7 +2166,8 @@ export default {
 		openBackofficeSearch: 'Agor chwiliad swyddfa gefn',
 		openCloseBackofficeHelp: 'Agor/Cau cymorth swyddfa gefn',
 		openCloseBackofficeProfileOptions: 'Agor/Cau eich opsiynau proffil',
-		profileOptions: 'Opsiynau proffil',
+		profileOptions: 'Proffil defnyddiwr ar gyfer %0% (%1%)',
+		profileOptionsDefault: 'Proffil defnyddiwr',
 		assignDomainDescription: 'Sefydli Diwylliannau ac Enwau Gwesteia am %0%',
 		createDescription: 'Creu nod newydd o dan %0%',
 		protectDescription: 'Sefydli Mynediad Cyhoeddus ar %0%',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/da.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/da.ts
index 257553d63bdb..8c590ff2b2c0 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/da.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/da.ts
@@ -616,7 +616,7 @@ export default {
 		noMacroParams: 'Der er ingen parametre for denne makro',
 		noMacros: 'Der er ikke tilføjet nogen makroer',
 		externalLoginProviders: 'Eksternt login',
-		exceptionDetail: 'Undtagelsesdetaljer',
+		exceptionDetail: 'Fejldetaljer',
 		stacktrace: 'Stacktrace',
 		innerException: 'Indre undtagelse',
 		linkYour: 'Link din {0} konto',
@@ -636,7 +636,7 @@ export default {
 		deleteLayout: 'You are deleting the layout',
 		deletingALayout:
 			'Modifying layout will result in loss of data for any existing content that is based on this configuration.',
-		seeErrorAction: 'Se fejlen',
+		seeErrorAction: 'Se hele fejlbeskeden',
 		seeErrorDialogHeadline: 'Fejl detaljer',
 		selectEvent: 'Vælg begivenhed',
 		editWebhook: 'Rediger webhook',
@@ -2025,7 +2025,7 @@ export default {
 		},
 		changePassword: 'Skift dit kodeord',
 		changePhoto: 'Skift billede',
-		configureMfa: 'Konfigurer MFA',
+		configureMfa: 'Konfigurer 2FA',
 		newPassword: 'Nyt kodeord',
 		newPasswordFormatLengthTip: 'Minium %0% karakterer tilbage!',
 		newPasswordFormatNonAlphaTip: 'Der skal som minium være %0% specielle karakterer.',
@@ -2263,6 +2263,10 @@ export default {
 		enableError:
 			'Der opstod en fejl under forsøget på at slå URL trackeren til, der findes mere information\n      i logfilen.\n    ',
 	},
+	embeddedMedia: {
+		dimensionsDescription:
+			'Disse værdier sendes som den maksimale bredde og højde til embed-udbyderen. Udbyderen kan justere de endelige dimensioner for at overholde sine egne begrænsninger.',
+	},
 	emptyStates: {
 		emptyDictionaryTree: 'Ingen ordbog elementer at vælge imellem',
 	},
@@ -2324,7 +2328,8 @@ export default {
 		openBackofficeSearch: 'Åben backoffice søgning',
 		openCloseBackofficeHelp: 'Åben/Luk backoffice hjælp',
 		openCloseBackofficeProfileOptions: 'Åben/Luk dine profil indstillinger',
-		profileOptions: 'Profil indstillinger',
+		profileOptions: 'Brugerprofil for %0% (%1%)',
+		profileOptionsDefault: 'Brugerprofil',
 		assignDomainDescription: 'Tilføj domæne på %0%',
 		createDescription: 'Opret ny node under %0%',
 		protectDescription: 'Opsæt offentlig adgang på %0%',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/de.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/de.ts
index cdf122cbf5f3..399716684e39 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/de.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/de.ts
@@ -1987,7 +1987,8 @@ export default {
 		openBackofficeSearch: 'Back-Office Suche öffnen',
 		openCloseBackofficeHelp: 'Back-Office Hilfe öffnen / schliessen',
 		openCloseBackofficeProfileOptions: 'Ihre Profil-Einstellungen öffnen / schliessen',
-		profileOptions: 'Profil-Einstellungen',
+		profileOptions: 'Benutzerprofil für %0% (%1%)',
+		profileOptionsDefault: 'Benutzerprofil',
 	},
 	logViewer: {
 		selectAllLogLevelFilters: 'Wählen Sie Alle',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/en.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/en.ts
index f68853058aac..5eba4c76f7e4 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/en.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/en.ts
@@ -686,7 +686,7 @@ export default {
 		deleteLayout: 'You are deleting the layout',
 		deletingALayout:
 			'Modifying layout will result in loss of data for any existing content that is based on this configuration.',
-		seeErrorAction: 'See error',
+		seeErrorAction: 'Full Error Message',
 		seeErrorDialogHeadline: 'Error details',
 	},
 	dictionary: {
@@ -975,6 +975,7 @@ export default {
 		rename: 'Rename',
 		renew: 'Renew',
 		required: 'Required',
+		reset: 'Reset',
 		retrieve: 'Retrieve',
 		retry: 'Retry',
 		rights: 'Permissions',
@@ -1794,6 +1795,8 @@ export default {
 		allowedTemplatesDescription: 'Choose which templates editors are allowed to use on content of this type',
 		allowAtRootHeading: 'Allow at root',
 		allowAtRootDescription: 'Allow editors to create content of this type in the root of the content tree.',
+		allowInLibraryHeading: 'Allow in Library',
+		allowInLibraryDescription: 'Allow editors to create Elements of this type in the Library section.',
 		childNodesHeading: 'Allowed child node types',
 		childNodesDescription: 'Allow content of the specified types to be created underneath content of this type.',
 		chooseChildNode: 'Choose child node',
@@ -2076,7 +2079,7 @@ export default {
 		},
 		changePassword: 'Change your password',
 		changePhoto: 'Change photo',
-		configureMfa: 'Configure MFA',
+		configureMfa: 'Configure 2FA',
 		emailRequired: 'Required - enter an email address for this user',
 		emailDescription: (usernameIsEmail: boolean) => {
 			return usernameIsEmail
@@ -2402,6 +2405,10 @@ export default {
 		enableError: 'Error enabling the URL tracker, more information can be found in your log file.',
 		culture: 'Culture',
 	},
+	embeddedMedia: {
+		dimensionsDescription:
+			'These values are passed as the maximum width and height to the embed provider. The provider may adjust the final dimensions to fit its own constraints.',
+	},
 	emptyStates: {
 		emptyDictionaryTree: 'No Dictionary items to choose from',
 	},
@@ -2464,7 +2471,8 @@ export default {
 		openBackofficeSearch: 'Open backoffice search',
 		openCloseBackofficeHelp: 'Open/Close backoffice help',
 		openCloseBackofficeProfileOptions: 'Open/Close your profile options',
-		profileOptions: 'Profile options',
+		profileOptions: 'User profile for %0% (%1%)',
+		profileOptionsDefault: 'User profile',
 		assignDomainDescription: 'Setup Culture and Hostnames for %0%',
 		createDescription: 'Create new node under %0%',
 		protectDescription: 'Setup access restrictions on %0%',
@@ -2895,6 +2903,9 @@ export default {
 	},
 	rte: {
 		label: 'Rich Text Editor',
+		config_allowedMediaTypes: 'Accepted media types',
+		config_allowedMediaTypes_description:
+			'Limit to specific media types for the media picker toolbar and drag-and-drop uploads.',
 		config_blocks: 'Available Blocks',
 		config_blocks_description: 'Define the available blocks.',
 		config_ignoreUserStartNodes: 'Ignore User Start Nodes',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/fr.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/fr.ts
index bb81db3c27cd..55586dea16eb 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/fr.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/fr.ts
@@ -1863,7 +1863,8 @@ export default {
 		openBackofficeSearch: 'Ouvrir la recherche backoffice',
 		openCloseBackofficeHelp: "Ouvrir/Fermer l'aide backoffice",
 		openCloseBackofficeProfileOptions: 'Ouvrir/Fermer vos options de profil',
-		profileOptions: 'Options de profil',
+		profileOptions: 'Profil utilisateur pour %0% (%1%)',
+		profileOptionsDefault: 'Profil utilisateur',
 		openContextMenu: 'Ouvrir le menu de contexte pour',
 		currentLanguage: 'Langue actuelle',
 		switchLanguage: 'Changer la langue vers',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/hr.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/hr.ts
index 82893cf67794..2236078e1d0f 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/hr.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/hr.ts
@@ -2045,7 +2045,8 @@ export default {
 		openBackofficeSearch: 'Otvorite backoffice pretragu',
 		openCloseBackofficeHelp: 'Otvori/Zatvori pomoć za backoffice',
 		openCloseBackofficeProfileOptions: 'Opcije otvaranja/zatvaranja profila',
-		profileOptions: 'Opcije profila',
+		profileOptions: 'Korisnički profil za %0% (%1%)',
+		profileOptionsDefault: 'Korisnički profil',
 		assignDomainDescription: 'Postavite kulturu i imena hostova za %0%',
 		createDescription: 'Kreirajte novi čvor ispod %0%',
 		protectDescription: 'Postavite ograničenja pristupa uključena %0%',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/it.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/it.ts
index 84ecbb67ad60..f8d73e0c25aa 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/it.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/it.ts
@@ -2074,7 +2074,8 @@ export default {
 		openBackofficeSearch: 'Apri la ricerca nel backoffice',
 		openCloseBackofficeHelp: "Apri/chiudi l'aiuto del backoffice",
 		openCloseBackofficeProfileOptions: 'Apri/chiudi le opzioni del tuo profilo',
-		profileOptions: 'Opzioni del profilo',
+		profileOptions: 'Profilo utente per %0% (%1%)',
+		profileOptionsDefault: 'Profilo utente',
 		assignDomainDescription: 'Imposta le Culture e gli Hostnames per %0%',
 		createDescription: 'Crea nuovo nodo sotto %0%',
 		protectDescription: 'Imposta le restrizioni di accesso per %0%',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/nl.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/nl.ts
index f61bc16b2d19..a5843e159df7 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/nl.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/nl.ts
@@ -1935,7 +1935,8 @@ export default {
 		openBackofficeSearch: 'Backoffice zoeken openen',
 		openCloseBackofficeHelp: 'Backoffice help openen/sluiten',
 		openCloseBackofficeProfileOptions: 'Jouw profiel opties openen/sluiten',
-		profileOptions: 'Profiel opties',
+		profileOptions: 'Gebruikersprofiel voor %0% (%1%)',
+		profileOptionsDefault: 'Gebruikersprofiel',
 		assignDomainDescription: 'Cultuur en Hostnamen instellen voor %0%',
 		createDescription: 'Nieuwe node aanmaken onder %0%',
 		protectDescription: 'Openbare toegang instellen op %0%',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/pt.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/pt.ts
index 1162d1cb1af7..9b20166c82d8 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/pt.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/pt.ts
@@ -2003,7 +2003,7 @@ export default {
 		},
 		changePassword: 'Altere a sua palavra-passe',
 		changePhoto: 'Alterar foto',
-		configureMfa: 'Configurar MFA',
+		configureMfa: 'Configurar 2FA',
 		emailRequired: 'Obrigatório - introduza um endereço de email para este utilizador',
 		emailDescription: (usernameIsEmail: boolean) => {
 			return usernameIsEmail
@@ -2365,7 +2365,8 @@ export default {
 		openBackofficeSearch: 'Abrir pesquisa do backoffice',
 		openCloseBackofficeHelp: 'Abrir/Fechar ajuda do backoffice',
 		openCloseBackofficeProfileOptions: 'Abrir/Fechar as opções do seu perfil',
-		profileOptions: 'Opções perfil',
+		profileOptions: 'Perfil do usuário para %0% (%1%)',
+		profileOptionsDefault: 'Perfil do usuário',
 		assignDomainDescription: 'Configurar Cultura e Domínios para %0%',
 		createDescription: 'Criar novo nó em %0%',
 		protectDescription: 'Configurar restrições de acesso em %0%',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/sv.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/sv.ts
index f19cd7eadecc..b7a0cf1ecfa7 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/sv.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/sv.ts
@@ -279,7 +279,8 @@ export default {
 		openBackofficeSearch: 'Öppna sökfunktion (backoffice)',
 		openCloseBackofficeHelp: 'Öppna/stäng hjälpfunktion',
 		openCloseBackofficeProfileOptions: 'Öppna/stäng personliga inställningar',
-		profileOptions: 'Personliga inställningar',
+		profileOptions: 'Användarprofil för %0% (%1%)',
+		profileOptionsDefault: 'Användarprofil',
 		assignDomainDescription: 'Redigera språk och värdnamn för %0%',
 		createDescription: 'Skapa en ny nod under %0%',
 		protectDescription: 'Ändra behörigheter för %0%',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/tr.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/tr.ts
index 30a3328d5708..85c9de91424d 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/tr.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/tr.ts
@@ -1812,7 +1812,8 @@ export default {
 		openBackofficeSearch: 'Arka ofis aramasını aç',
 		openCloseBackofficeHelp: 'Backoffice yardımını Aç / Kapat',
 		openCloseBackofficeProfileOptions: 'Profil seçeneklerinizi açın / kapatın',
-		profileOptions: 'Profil seçenekleri',
+		profileOptions: 'Kullanıcı profili %0% (%1%) için',
+		profileOptionsDefault: 'Kullanıcı profili',
 		assignDomainDescription: '%0% için Kurulum Kültürü ve Ana Bilgisayar Adları',
 		createDescription: '%0% altında yeni düğüm oluştur',
 		protectDescription: '%0% üzerinde genel erişim kurun',
diff --git a/src/Umbraco.Web.UI.Client/src/assets/lang/vi.ts b/src/Umbraco.Web.UI.Client/src/assets/lang/vi.ts
index f3eb62ab3945..7950336b1763 100644
--- a/src/Umbraco.Web.UI.Client/src/assets/lang/vi.ts
+++ b/src/Umbraco.Web.UI.Client/src/assets/lang/vi.ts
@@ -2010,7 +2010,7 @@ export default {
 		},
 		changePassword: 'Đổi mật khẩu',
 		changePhoto: 'Đổi ảnh',
-		configureMfa: 'Cấu hình MFA',
+		configureMfa: 'Cấu hình 2FA',
 		emailRequired: 'Bắt buộc - nhập địa chỉ email cho người dùng này',
 		emailDescription: (usernameIsEmail: boolean) => {
 			return usernameIsEmail
@@ -2368,7 +2368,8 @@ export default {
 		openBackofficeSearch: 'Mở tìm kiếm backoffice',
 		openCloseBackofficeHelp: 'Mở/Đóng trợ giúp backoffice',
 		openCloseBackofficeProfileOptions: 'Mở/Đóng tùy chọn hồ sơ của bạn',
-		profileOptions: 'Tùy chọn hồ sơ',
+		profileOptions: 'Hồ sơ người dùng cho %0% (%1%)',
+		profileOptionsDefault: 'Hồ sơ người dùng',
 		assignDomainDescription: 'Thiết lập Ngôn ngữ và Tên miền cho %0%',
 		createDescription: 'Tạo nút mới dưới %0%',
 		protectDescription: 'Thiết lập hạn chế truy cập trên %0%',
diff --git a/src/Umbraco.Web.UI.Client/src/css/dark.theme.css b/src/Umbraco.Web.UI.Client/src/css/dark.theme.css
deleted file mode 100644
index 5b3cb0429e11..000000000000
--- a/src/Umbraco.Web.UI.Client/src/css/dark.theme.css
+++ /dev/null
@@ -1,48 +0,0 @@
-:root {
-	--uui-color-selected: #316dca;
-	--uui-color-selected-emphasis: #3e79d0;
-	--uui-color-selected-standalone: #5b8dd7;
-	--uui-color-selected-contrast: #eeeeef;
-	--uui-color-current: #316dca;
-	--uui-color-current-emphasis: #3e79d0;
-	--uui-color-current-standalone: #5b8dd7;
-	--uui-color-current-contrast: #eeeeef;
-	--uui-color-disabled: #434c56;
-	--uui-color-disabled-standalone: #545d68;
-	--uui-color-disabled-contrast: #fcfcfc4d;
-	--uui-color-header-surface: #21262e;
-	--uui-color-header-contrast: #eeeeef;
-	--uui-color-header-contrast-emphasis: #eeeeef;
-	--uui-color-focus: #316dca;
-	--uui-color-surface: #2d333b;
-	--uui-color-surface-alt: #373e47;
-	--uui-color-surface-emphasis: #333a42;
-	--uui-color-background: #21262e;
-	--uui-color-text: #eeeeef;
-	--uui-color-text-alt: #eeeeef;
-	--uui-color-interactive: #eeeeef;
-	--uui-color-interactive-emphasis: #eeeeef;
-	--uui-color-border: #434c56;
-	--uui-color-border-standalone: #545d68;
-	--uui-color-border-emphasis: #626e7b;
-	--uui-color-divider: #373e47;
-	--uui-color-divider-standalone: #434c56;
-	--uui-color-divider-emphasis: #545d68;
-	--uui-color-default: #316dca;
-	--uui-color-default-emphasis: #5387d5;
-	--uui-color-default-standalone: #eeeeef;
-	--uui-color-default-contrast: #eeeeef;
-	--uui-color-warning: #af7c12;
-	--uui-color-warning-emphasis: #af7c12;
-	--uui-color-warning-standalone: #af7c12;
-	--uui-color-warning-contrast: #eeeeef;
-	--uui-color-danger: #ca3b37;
-	--uui-color-danger-emphasis: #ca3b37;
-	--uui-color-danger-standalone: #ca3b37;
-	--uui-color-danger-contrast: #eeeeef;
-	--uui-color-positive: #347d39;
-	--uui-color-positive-emphasis: #347d39;
-	--uui-color-positive-standalone: #347d39;
-	--uui-color-positive-contrast: #eeeeef;
-	--uui-color-scheme: dark;
-}
diff --git a/src/Umbraco.Web.UI.Client/src/css/high-contrast.theme.css b/src/Umbraco.Web.UI.Client/src/css/high-contrast.theme.css
deleted file mode 100644
index 6e84c57c7e7a..000000000000
--- a/src/Umbraco.Web.UI.Client/src/css/high-contrast.theme.css
+++ /dev/null
@@ -1,53 +0,0 @@
-:root {
-	--uui-color-selected: var(--uui-palette-violet-blue, #3544b1);
-	--uui-color-selected-emphasis: var(--uui-palette-violet-blue-light, rgb(70, 86, 200));
-	--uui-color-selected-standalone: var(--uui-palette-violet-blue-dark, rgb(54, 65, 156));
-	--uui-color-selected-contrast: #fff;
-	--uui-color-current: var(--uui-palette-spanish-pink, #f5c1bc);
-	--uui-color-current-emphasis: var(--uui-palette-spanish-pink-light, rgb(248, 214, 211));
-	--uui-color-current-standalone: var(--uui-palette-spanish-pink-dark, rgb(232, 192, 189));
-	--uui-color-current-contrast: var(--uui-palette-space-cadet, #1b264f);
-	--uui-color-disabled: var(--uui-palette-sand, #f3f3f5);
-	--uui-color-disabled-standalone: var(--uui-palette-sand-dark, rgb(226, 226, 226));
-	--uui-color-disabled-contrast: var(--uui-palette-grey, #c4c4c4);
-	--uui-color-header-surface: var(--uui-palette-space-cadet, #1b264f);
-	--uui-color-header-contrast: #fff;
-	--uui-color-header-contrast-emphasis: #fff;
-	--uui-color-focus: var(--uui-palette-malibu, #3879ff);
-	--uui-color-surface: #fff;
-	--uui-color-surface-alt: #fff;
-	--uui-color-surface-emphasis: #dadada;
-	--uui-color-background: #fff;
-	--uui-color-text: var(--uui-palette-black, #060606);
-	--uui-color-text-alt: var(--uui-palette-dune-black, #2e2b29);
-	--uui-color-interactive: var(--uui-palette-space-cadet, #1b264f);
-	--uui-color-interactive-emphasis: var(--uui-palette-violet-blue, #3544b1);
-	--uui-color-border: #000000;
-	--uui-color-border-standalone: #000000;
-	--uui-color-border-emphasis: #000000;
-	--uui-color-divider: #000000;
-	--uui-color-divider-standalone: #000000;
-	--uui-color-divider-emphasis: #000000;
-	--uui-color-default: var(--uui-palette-space-cadet, #1b264f);
-	--uui-color-default-emphasis: var(--uui-palette-violet-blue, #3544b1);
-	--uui-color-default-standalone: var(--uui-palette-space-cadet-dark, rgb(28, 35, 59));
-	--uui-color-default-contrast: #fff;
-	--uui-color-warning: #ffd621;
-	--uui-color-warning-emphasis: #ffdc41;
-	--uui-color-warning-standalone: #ffdd43;
-	--uui-color-warning-contrast: #000;
-	--uui-color-danger: #c60239;
-	--uui-color-danger-emphasis: #da114a;
-	--uui-color-danger-standalone: #d0003b;
-	--uui-color-danger-contrast: white;
-	--uui-color-positive: #0d8844;
-	--uui-color-positive-emphasis: #159c52;
-	--uui-color-positive-standalone: #1cae5e;
-	--uui-color-positive-contrast: #fff;
-
-	--uui-shadow-depth-1: 0 0 0px 1px black;
-	--uui-shadow-depth-2: 0 0 0px 1px black;
-	--uui-shadow-depth-3: 0 0 0px 1px black;
-	--uui-shadow-depth-4: 0 0 0px 1px black;
-	--uui-shadow-depth-5: 0 0 0px 1px black;
-}
diff --git a/src/Umbraco.Web.UI.Client/src/external/uui/package.json b/src/Umbraco.Web.UI.Client/src/external/uui/package.json
index 5c1d40dbe304..c2debf2493e5 100644
--- a/src/Umbraco.Web.UI.Client/src/external/uui/package.json
+++ b/src/Umbraco.Web.UI.Client/src/external/uui/package.json
@@ -6,7 +6,6 @@
 		"build": "vite build"
 	},
 	"dependencies": {
-		"@umbraco-ui/uui": "^1.17.2",
-		"@umbraco-ui/uui-css": "^1.17.1"
+		"@umbraco-ui/uui": "^2.0.0-alpha.1"
 	}
 }
diff --git a/src/Umbraco.Web.UI.Client/src/external/uui/vite.config.ts b/src/Umbraco.Web.UI.Client/src/external/uui/vite.config.ts
index 67f1d1d6d283..b564301fe7b5 100644
--- a/src/Umbraco.Web.UI.Client/src/external/uui/vite.config.ts
+++ b/src/Umbraco.Web.UI.Client/src/external/uui/vite.config.ts
@@ -8,13 +8,16 @@ const distAssets = '../../../dist-cms';
 // delete the unbundled dist folder
 rmSync(dist, { recursive: true, force: true });
 
-// copy css
-cpSync('../../../node_modules/@umbraco-ui/uui-css/dist/uui-css.css', `${distAssets}/css/uui-css.css`, {
+// Copy UUI theme CSS (dark.css, high-contrast.css, etc.) into dist-cms/css/.
+// These are served at /umbraco/backoffice/css/ and referenced by theme manifests
+// in src/packages/core/themes/manifests.ts. If UUI changes its theme filenames,
+// update the manifests to match.
+cpSync('../../../node_modules/@umbraco-ui/uui/dist/themes', `${distAssets}/css`, {
 	recursive: true,
 });
 
 // copy fonts
-cpSync('../../../node_modules/@umbraco-ui/uui-css/assets/fonts', `${distAssets}/assets/fonts`, {
+cpSync('../../../node_modules/@umbraco-ui/uui/dist/assets/fonts', `${distAssets}/assets/fonts`, {
 	recursive: true,
 });
 
diff --git a/src/Umbraco.Web.UI.Client/src/mocks/data/data-type/data-type.data.ts b/src/Umbraco.Web.UI.Client/src/mocks/data/data-type/data-type.data.ts
index 47253df01057..18120262864b 100644
--- a/src/Umbraco.Web.UI.Client/src/mocks/data/data-type/data-type.data.ts
+++ b/src/Umbraco.Web.UI.Client/src/mocks/data/data-type/data-type.data.ts
@@ -1186,6 +1186,7 @@ export const data: Array<UmbMockDataTypeModel> = [
 			{ alias: 'stylesheets', value: ['/rte-styles.css'] },
 			{ alias: 'dimensions', value: { height: 500 } },
 			{ alias: 'maxImageSize', value: 500 },
+			{ alias: 'allowedMediaTypes', value: 'media-type-1-id,media-type-3-id' },
 			{ alias: 'ignoreUserStartNodes', value: false },
 			{ alias: 'overlaySize', value: 'medium' },
 		],
diff --git a/src/Umbraco.Web.UI.Client/src/mocks/data/document-type/document-type.data.ts b/src/Umbraco.Web.UI.Client/src/mocks/data/document-type/document-type.data.ts
index 849f163f793f..5b10483cffe3 100644
--- a/src/Umbraco.Web.UI.Client/src/mocks/data/document-type/document-type.data.ts
+++ b/src/Umbraco.Web.UI.Client/src/mocks/data/document-type/document-type.data.ts
@@ -19,6 +19,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-document',
 		allowedAsRoot: true,
+		allowedInLibrary: false,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: false,
@@ -65,7 +66,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		},
 		flags: [],
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -76,6 +76,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-item-arrangement',
 		allowedAsRoot: true,
+		allowedInLibrary: false,
 		variesByCulture: true,
 		variesBySegment: false,
 		isElement: false,
@@ -858,7 +859,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			keepLatestVersionPerDayForDays: null,
 		},
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -869,6 +869,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-eco',
 		allowedAsRoot: true,
+		allowedInLibrary: false,
 		variesByCulture: true,
 		variesBySegment: false,
 		isElement: false,
@@ -939,7 +940,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		},
 		collection: { id: 'dt-collectionView' },
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -950,6 +950,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-document',
 		allowedAsRoot: true,
+		allowedInLibrary: false,
 		variesByCulture: true,
 		variesBySegment: true,
 		isElement: false,
@@ -1111,7 +1112,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			keepLatestVersionPerDayForDays: null,
 		},
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [{ id: '916cfecc-3295-490c-a16d-c41fa9f72980' }],
@@ -1124,6 +1124,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-document',
 		allowedAsRoot: false,
+		allowedInLibrary: false,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: false,
@@ -1170,7 +1171,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			keepLatestVersionPerDayForDays: null,
 		},
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1181,6 +1181,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-lab',
 		allowedAsRoot: false,
+		allowedInLibrary: true,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: true,
@@ -1274,7 +1275,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			keepLatestVersionPerDayForDays: null,
 		},
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1285,6 +1285,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-lab',
 		allowedAsRoot: false,
+		allowedInLibrary: true,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: true,
@@ -1331,7 +1332,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			keepLatestVersionPerDayForDays: null,
 		},
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [
@@ -1352,6 +1352,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-document',
 		allowedAsRoot: true,
+		allowedInLibrary: false,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: false,
@@ -1401,7 +1402,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			keepLatestVersionPerDayForDays: null,
 		},
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1412,6 +1412,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-document',
 		allowedAsRoot: true,
+		allowedInLibrary: false,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: false,
@@ -1478,7 +1479,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			keepLatestVersionPerDayForDays: null,
 		},
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1489,6 +1489,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-folder',
 		allowedAsRoot: true,
+		allowedInLibrary: false,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: false,
@@ -1506,7 +1507,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		containers: [],
 		flags: [],
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1517,6 +1517,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: 'The delicious taste of coffee.',
 		icon: 'icon-coffee',
 		allowedAsRoot: true,
+		allowedInLibrary: true,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: true,
@@ -1583,7 +1584,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			},
 		],
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1594,6 +1594,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-edit',
 		allowedAsRoot: true,
+		allowedInLibrary: true,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: true,
@@ -1640,7 +1641,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			},
 		],
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1651,6 +1651,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-edit',
 		allowedAsRoot: true,
+		allowedInLibrary: true,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: true,
@@ -1697,7 +1698,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			},
 		],
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1708,6 +1708,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-picture',
 		allowedAsRoot: true,
+		allowedInLibrary: true,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: true,
@@ -1754,7 +1755,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			},
 		],
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1765,6 +1765,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-diploma',
 		allowedAsRoot: true,
+		allowedInLibrary: true,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: true,
@@ -1811,7 +1812,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			},
 		],
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1822,6 +1822,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-book-alt',
 		allowedAsRoot: true,
+		allowedInLibrary: true,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: true,
@@ -1841,7 +1842,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		containers: [],
 		flags: [],
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1852,6 +1852,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-war',
 		allowedAsRoot: true,
+		allowedInLibrary: true,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: true,
@@ -1869,7 +1870,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		properties: [],
 		containers: [],
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1880,6 +1880,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-document',
 		allowedAsRoot: true,
+		allowedInLibrary: false,
 		variesByCulture: true,
 		variesBySegment: false,
 		isElement: false,
@@ -1927,7 +1928,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			keepLatestVersionPerDayForDays: null,
 		},
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -1938,6 +1938,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-item-arrangement',
 		allowedAsRoot: true,
+		allowedInLibrary: false,
 		variesByCulture: true,
 		variesBySegment: false,
 		isElement: false,
@@ -2004,7 +2005,6 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			keepLatestVersionPerDayForDays: null,
 		},
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		allowedTemplates: [],
@@ -2015,6 +2015,7 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 		description: null,
 		icon: 'icon-document',
 		allowedAsRoot: true,
+		allowedInLibrary: false,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: false,
@@ -2061,6 +2062,5 @@ export const data: Array<UmbMockDocumentTypeModel> = [
 			keepLatestVersionPerDayForDays: null,
 		},
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 ];
diff --git a/src/Umbraco.Web.UI.Client/src/mocks/data/document-type/document-type.db.ts b/src/Umbraco.Web.UI.Client/src/mocks/data/document-type/document-type.db.ts
index eb5416598535..84543c4fd5fe 100644
--- a/src/Umbraco.Web.UI.Client/src/mocks/data/document-type/document-type.db.ts
+++ b/src/Umbraco.Web.UI.Client/src/mocks/data/document-type/document-type.db.ts
@@ -58,6 +58,7 @@ const createMockDocumentTypeFolderMapper = (request: CreateFolderRequestModel):
 		properties: [],
 		containers: [],
 		allowedAsRoot: false,
+		allowedInLibrary: false,
 		variesByCulture: false,
 		variesBySegment: false,
 		isElement: false,
@@ -73,7 +74,6 @@ const createMockDocumentTypeFolderMapper = (request: CreateFolderRequestModel):
 		},
 		flags: [],
 		noAccess: false,
-		allowedInLibrary: false,
 	};
 };
 
@@ -87,6 +87,7 @@ const createMockDocumentTypeMapper = (request: CreateDocumentTypeRequestModel):
 		properties: request.properties,
 		containers: request.containers,
 		allowedAsRoot: request.allowedAsRoot,
+		allowedInLibrary: request.allowedInLibrary,
 		variesByCulture: request.variesByCulture,
 		variesBySegment: request.variesBySegment,
 		isElement: request.isElement,
@@ -103,7 +104,6 @@ const createMockDocumentTypeMapper = (request: CreateDocumentTypeRequestModel):
 		},
 		flags: [],
 		noAccess: false,
-		allowedInLibrary: request.allowedInLibrary,
 	};
 };
 
@@ -117,6 +117,7 @@ const documentTypeDetailMapper = (item: UmbMockDocumentTypeModel): DocumentTypeR
 		properties: item.properties,
 		containers: item.containers,
 		allowedAsRoot: item.allowedAsRoot,
+		allowedInLibrary: item.allowedInLibrary,
 		variesByCulture: item.variesByCulture,
 		variesBySegment: item.variesBySegment,
 		isElement: item.isElement,
@@ -125,7 +126,6 @@ const documentTypeDetailMapper = (item: UmbMockDocumentTypeModel): DocumentTypeR
 		allowedTemplates: item.allowedTemplates,
 		cleanup: item.cleanup,
 		collection: item.collection,
-		allowedInLibrary: item.allowedInLibrary,
 	};
 };
 
diff --git a/src/Umbraco.Web.UI.Client/src/mocks/data/element/element.data.ts b/src/Umbraco.Web.UI.Client/src/mocks/data/element/element.data.ts
index 7d56e085c4ca..62d0bea49815 100644
--- a/src/Umbraco.Web.UI.Client/src/mocks/data/element/element.data.ts
+++ b/src/Umbraco.Web.UI.Client/src/mocks/data/element/element.data.ts
@@ -39,6 +39,8 @@ export const data: Array<UmbMockElementModel> = [
 				createDate: '2024-01-15T10:00:00.000Z',
 				updateDate: '2024-01-15T10:00:00.000Z',
 				publishDate: '2024-01-15T10:00:00.000Z',
+				id: 'simple-element',
+				flags: [],
 			},
 		],
 		values: [
@@ -90,6 +92,8 @@ export const data: Array<UmbMockElementModel> = [
 				createDate: '2024-01-16T14:00:00.000Z',
 				updateDate: '2024-01-16T14:00:00.000Z',
 				publishDate: '2024-01-16T14:00:00.000Z',
+				id: 'element-in-folder',
+				flags: [],
 			},
 		],
 		values: [
@@ -141,6 +145,8 @@ export const data: Array<UmbMockElementModel> = [
 				createDate: '2024-01-16T14:00:00.000Z',
 				updateDate: '2024-01-16T14:00:00.000Z',
 				publishDate: '2024-01-16T14:00:00.000Z',
+				id: 'element-in-subfolder-1',
+				flags: [],
 			},
 		],
 		values: [
@@ -155,4 +161,80 @@ export const data: Array<UmbMockElementModel> = [
 		flags: [],
 		noAccess: false,
 	},
+	{
+		ancestors: [],
+		id: 'element-with-pending-changes-id',
+		createDate: '2024-01-17T08:00:00.000Z',
+		parent: null,
+		documentType: {
+			id: '4f68ba66-6fb2-4778-83b8-6ab4ca3a7c5c',
+			icon: 'icon-lab',
+		},
+		hasChildren: false,
+		isTrashed: false,
+		isFolder: false,
+		name: 'Element With Pending Changes',
+		variants: [
+			{
+				state: DocumentVariantStateModel.PUBLISHED_PENDING_CHANGES,
+				culture: null,
+				segment: null,
+				name: 'Element With Pending Changes',
+				createDate: '2024-01-17T08:00:00.000Z',
+				updateDate: '2024-01-18T09:00:00.000Z',
+				publishDate: '2024-01-17T08:00:00.000Z',
+				id: 'element-with-pending-changes',
+				flags: [{ alias: 'Umb.PendingChanges' }],
+			},
+		],
+		values: [
+			{
+				editorAlias: 'Umbraco.TextBox',
+				alias: 'elementProperty',
+				culture: null,
+				segment: null,
+				value: 'This element has unpublished changes.',
+			},
+		],
+		flags: [],
+		noAccess: false,
+	},
+	{
+		ancestors: [],
+		id: 'element-with-scheduled-publish-id',
+		createDate: '2024-01-17T08:00:00.000Z',
+		parent: null,
+		documentType: {
+			id: '4f68ba66-6fb2-4778-83b8-6ab4ca3a7c5c',
+			icon: 'icon-lab',
+		},
+		hasChildren: false,
+		isTrashed: false,
+		isFolder: false,
+		name: 'Element With Scheduled Publish',
+		variants: [
+			{
+				state: DocumentVariantStateModel.PUBLISHED,
+				culture: null,
+				segment: null,
+				name: 'Element With Scheduled Publish',
+				createDate: '2024-01-17T08:00:00.000Z',
+				updateDate: '2024-01-17T08:00:00.000Z',
+				publishDate: '2024-01-17T08:00:00.000Z',
+				id: 'element-with-scheduled-publish',
+				flags: [{ alias: 'Umb.ScheduledForPublish' }],
+			},
+		],
+		values: [
+			{
+				editorAlias: 'Umbraco.TextBox',
+				alias: 'elementProperty',
+				culture: null,
+				segment: null,
+				value: 'This element has a scheduled publish date.',
+			},
+		],
+		flags: [{ alias: 'Umb.ScheduledForPublish' }],
+		noAccess: false,
+	},
 ];
diff --git a/src/Umbraco.Web.UI.Client/src/mocks/data/element/element.db.ts b/src/Umbraco.Web.UI.Client/src/mocks/data/element/element.db.ts
index 929bdad400df..5fca415031d2 100644
--- a/src/Umbraco.Web.UI.Client/src/mocks/data/element/element.db.ts
+++ b/src/Umbraco.Web.UI.Client/src/mocks/data/element/element.db.ts
@@ -109,6 +109,8 @@ const createMockElementMapper = (request: CreateElementRequestModel): UmbMockEle
 				updateDate: now,
 				state: DocumentVariantStateModel.DRAFT,
 				publishDate: null,
+				id: UmbId.new(),
+				flags: [],
 			};
 		}),
 		flags: [],
@@ -163,6 +165,8 @@ const detailResponseMapper = (model: UmbMockElementModel): ElementResponseModel
 			publishDate: null,
 			scheduledPublishDate: null,
 			scheduledUnpublishDate: null,
+			id: v.id,
+			flags: v.flags ?? [],
 		})),
 		flags: model.flags,
 	};
diff --git a/src/Umbraco.Web.UI.Client/src/mocks/data/media-type/media-type.data.ts b/src/Umbraco.Web.UI.Client/src/mocks/data/media-type/media-type.data.ts
index a8a657fb71ff..134fc6da34f1 100644
--- a/src/Umbraco.Web.UI.Client/src/mocks/data/media-type/media-type.data.ts
+++ b/src/Umbraco.Web.UI.Client/src/mocks/data/media-type/media-type.data.ts
@@ -4,12 +4,12 @@ import type {
 	MediaTypeTreeItemResponseModel,
 } from '@umbraco-cms/backoffice/external/backend-api';
 
-export type UmbMockMediaTypeModel = MediaTypeResponseModel &
+export type UmbMockMediaTypeModel = Omit<MediaTypeResponseModel, 'allowedInLibrary'> &
 	MediaTypeTreeItemResponseModel &
 	MediaTypeItemResponseModel;
 
 export type UmbMockMediaTypeUnionModel =
-	| MediaTypeResponseModel
+	| Omit<MediaTypeResponseModel, 'allowedInLibrary'>
 	| MediaTypeTreeItemResponseModel
 	| MediaTypeItemResponseModel;
 
@@ -105,7 +105,6 @@ export const data: Array<UmbMockMediaTypeModel> = [
 		isDeletable: false,
 		aliasCanBeChanged: false,
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		name: 'Audio',
@@ -158,7 +157,6 @@ export const data: Array<UmbMockMediaTypeModel> = [
 		isDeletable: false,
 		aliasCanBeChanged: false,
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		name: 'Vector Graphics',
@@ -211,7 +209,6 @@ export const data: Array<UmbMockMediaTypeModel> = [
 		isDeletable: false,
 		aliasCanBeChanged: false,
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		name: 'Movie',
@@ -264,7 +261,6 @@ export const data: Array<UmbMockMediaTypeModel> = [
 		isDeletable: false,
 		aliasCanBeChanged: false,
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		name: 'Media Type 5',
@@ -317,7 +313,6 @@ export const data: Array<UmbMockMediaTypeModel> = [
 		isDeletable: false,
 		aliasCanBeChanged: false,
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 	{
 		name: 'A Forbidden Media Type',
@@ -370,6 +365,5 @@ export const data: Array<UmbMockMediaTypeModel> = [
 		isDeletable: true,
 		aliasCanBeChanged: false,
 		noAccess: false,
-		allowedInLibrary: false,
 	},
 ];
diff --git a/src/Umbraco.Web.UI.Client/src/mocks/data/media-type/media-type.db.ts b/src/Umbraco.Web.UI.Client/src/mocks/data/media-type/media-type.db.ts
index c7bd6ec85aa4..20883794b71e 100644
--- a/src/Umbraco.Web.UI.Client/src/mocks/data/media-type/media-type.db.ts
+++ b/src/Umbraco.Web.UI.Client/src/mocks/data/media-type/media-type.db.ts
@@ -93,7 +93,6 @@ const createMockMediaTypeFolderMapper = (request: CreateFolderRequestModel): Umb
 		aliasCanBeChanged: false,
 		flags: [],
 		noAccess: false,
-		allowedInLibrary: false,
 	};
 };
 
@@ -120,7 +119,6 @@ const createMockMediaTypeMapper = (request: CreateMediaTypeRequestModel): UmbMoc
 		aliasCanBeChanged: false,
 		flags: [],
 		noAccess: false,
-		allowedInLibrary: request.allowedInLibrary,
 	};
 };
 
@@ -134,6 +132,7 @@ const mediaTypeDetailMapper = (item: UmbMockMediaTypeModel): MediaTypeResponseMo
 		properties: item.properties,
 		containers: item.containers,
 		allowedAsRoot: item.allowedAsRoot,
+		allowedInLibrary: false,
 		variesByCulture: item.variesByCulture,
 		variesBySegment: item.variesBySegment,
 		isElement: item.isElement,
@@ -142,7 +141,6 @@ const mediaTypeDetailMapper = (item: UmbMockMediaTypeModel): MediaTypeResponseMo
 		collection: item.collection,
 		isDeletable: item.isDeletable,
 		aliasCanBeChanged: item.aliasCanBeChanged,
-		allowedInLibrary: item.allowedInLibrary,
 	};
 };
 
diff --git a/src/Umbraco.Web.UI.Client/src/mocks/data/member-type/member-type.data.ts b/src/Umbraco.Web.UI.Client/src/mocks/data/member-type/member-type.data.ts
index d1053acfdb6e..a49b64776bfa 100644
--- a/src/Umbraco.Web.UI.Client/src/mocks/data/member-type/member-type.data.ts
+++ b/src/Umbraco.Web.UI.Client/src/mocks/data/member-type/member-type.data.ts
@@ -3,7 +3,7 @@ import type {
 	MemberTypeResponseModel,
 } from '@umbraco-cms/backoffice/external/backend-api';
 
-export type UmbMockMemberTypeModel = MemberTypeResponseModel &
+export type UmbMockMemberTypeModel = Omit<MemberTypeResponseModel, 'allowedInLibrary'> &
 	MemberTypeItemResponseModel & {
 		hasChildren: boolean;
 		parent: { id: string } | null;
@@ -59,7 +59,6 @@ export const data: Array<UmbMockMemberTypeModel> = [
 		hasChildren: false,
 		hasListView: false,
 		flags: [],
-		allowedInLibrary: false,
 	},
 	{
 		name: 'A Forbidden Member Type',
@@ -109,6 +108,5 @@ export const data: Array<UmbMockMemberTypeModel> = [
 		parent: null,
 		hasChildren: false,
 		hasListView: false,
-		allowedInLibrary: false,
 	},
 ];
diff --git a/src/Umbraco.Web.UI.Client/src/mocks/data/member-type/member-type.db.ts b/src/Umbraco.Web.UI.Client/src/mocks/data/member-type/member-type.db.ts
index 51f6f44bc2a0..8b4a543ad8fc 100644
--- a/src/Umbraco.Web.UI.Client/src/mocks/data/member-type/member-type.db.ts
+++ b/src/Umbraco.Web.UI.Client/src/mocks/data/member-type/member-type.db.ts
@@ -39,7 +39,6 @@ const createDetailMockMapper = (request: CreateMemberTypeRequestModel): UmbMockM
 		parent: null,
 		hasListView: false,
 		flags: [],
-		allowedInLibrary: request.allowedInLibrary,
 	};
 };
 
@@ -53,11 +52,11 @@ const detailResponseMapper = (item: UmbMockMemberTypeModel): MemberTypeResponseM
 		properties: item.properties,
 		containers: item.containers,
 		allowedAsRoot: item.allowedAsRoot,
+		allowedInLibrary: false,
 		variesByCulture: item.variesByCulture,
 		variesBySegment: item.variesBySegment,
 		isElement: item.isElement,
 		compositions: item.compositions,
-		allowedInLibrary: item.allowedInLibrary,
 	};
 };
 
diff --git a/src/Umbraco.Web.UI.Client/src/packages/block/block/context/block-manager.context.ts b/src/Umbraco.Web.UI.Client/src/packages/block/block/context/block-manager.context.ts
index 8ca38f970dd4..56701ed365bc 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/block/block/context/block-manager.context.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/block/block/context/block-manager.context.ts
@@ -442,7 +442,6 @@ export abstract class UmbBlockManagerContext<
 	}
 
 	protected async _createBlockElementData(key: string, contentTypeKey: string) {
-		//
 		const appLanguage = await this.getContext(UMB_APP_LANGUAGE_CONTEXT);
 		if (!appLanguage) {
 			throw new Error('Could not retrieve app language context.');
@@ -453,13 +452,21 @@ export abstract class UmbBlockManagerContext<
 			throw new Error(`Cannot create Preset for Block, missing content structure for ${contentTypeKey}`);
 		}
 
-		// Set culture and segment for all values:
-		const cutlures = contentStructure.variesByCulture ? await appLanguage.getCultures() : [];
-		if (cutlures.length === 0) {
+		// Ensure the content type and all its compositions are fully loaded before reading properties.
+		// Without this, getContentTypeProperties() may return only the owner type's properties
+		// if compositions haven't finished loading yet.
+		await contentStructure.whenLoaded();
+
+		// Use the synchronous boolean getters, not the Observable properties (which are always truthy).
+		const hostVariesByCulture = contentStructure.getVariesByCulture() ?? false;
+		const hostVariesBySegment = contentStructure.getVariesBySegment() ?? false;
+
+		const cultures = hostVariesByCulture ? await appLanguage.getCultures() : [];
+		if (hostVariesByCulture && cultures.length === 0) {
 			throw new Error('Could not retrieve app cultures.');
 		}
 		// TODO: Receive the segments from somewhere. [NL]
-		const segments: Array<string> | undefined = contentStructure.variesBySegment ? [] : undefined;
+		const segments: Array<string> | undefined = hostVariesBySegment ? [] : undefined;
 
 		const repo = new UmbDataTypeDetailRepository(this);
 
@@ -482,15 +489,19 @@ export abstract class UmbBlockManagerContext<
 					propertyEditorSchemaAlias: dataType.editorAlias,
 					config: dataType.values,
 					typeArgs: {
-						variesByCulture: property.variesByCulture,
-						variesBySegment: property.variesBySegment,
+						// Normalize property variance against the host content type, mirroring the
+						// server-side logic in ContentTypeCompositionBase (propertyType.Variations &= Variations).
+						// Properties from compositions are loaded individually and carry their own variance flags,
+						// which may not match the host's effective variance (GH-22230).
+						variesByCulture: property.variesByCulture && hostVariesByCulture,
+						variesBySegment: property.variesBySegment && hostVariesBySegment,
 					} as UmbPropertyTypePresetModelTypeModel,
 				} as UmbPropertyTypePresetModel;
 			}),
 		);
 
 		const controller = new UmbPropertyValuePresetVariantBuilderController(this);
-		controller.setCultures(cutlures);
+		controller.setCultures(cultures);
 		if (segments) {
 			controller.setSegments(segments);
 		}
@@ -500,8 +511,6 @@ export abstract class UmbBlockManagerContext<
 			entityTypeUnique: contentTypeKey,
 		});
 
-		// Set culture and segment for all values:
-
 		return {
 			key,
 			contentTypeKey,
diff --git a/src/Umbraco.Web.UI.Client/src/packages/content/content-type/types.ts b/src/Umbraco.Web.UI.Client/src/packages/content/content-type/types.ts
index 0328906ef354..53b709911cf3 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/content/content-type/types.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/content/content-type/types.ts
@@ -42,7 +42,6 @@ export interface UmbContentTypeModel {
 	variesByCulture: boolean;
 	variesBySegment: boolean;
 	isElement: boolean;
-	allowedInLibrary: boolean;
 	properties: Array<UmbPropertyTypeModel>;
 	containers: Array<UmbPropertyTypeContainerModel>;
 	allowedContentTypes: Array<UmbContentTypeSortModel>;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/content/content/audit-log/info-app/content-audit-log-workspace-info-app.element.ts b/src/Umbraco.Web.UI.Client/src/packages/content/content/audit-log/info-app/content-audit-log-workspace-info-app.element.ts
index 2c385d8d941b..10ae1e164e24 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/content/content/audit-log/info-app/content-audit-log-workspace-info-app.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/content/content/audit-log/info-app/content-audit-log-workspace-info-app.element.ts
@@ -3,7 +3,7 @@ import type { ManifestWorkspaceInfoAppAuditLogKind } from './types.js';
 import { css, customElement, html, nothing, property, repeat, state, when } from '@umbraco-cms/backoffice/external/lit';
 import { createExtensionApiByAlias } from '@umbraco-cms/backoffice/extension-registry';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import { UmbPaginationManager } from '@umbraco-cms/backoffice/utils';
+import { UmbPaginationManager, UMB_DATE_TIME_FORMAT_OPTIONS } from '@umbraco-cms/backoffice/utils';
 import { UmbRequestReloadStructureForEntityEvent } from '@umbraco-cms/backoffice/entity-action';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
 import { UmbUserItemRepository } from '@umbraco-cms/backoffice/user';
@@ -13,15 +13,6 @@ import type { UmbAuditLogModel, UmbAuditLogRepository } from '@umbraco-cms/backo
 import type { UmbUserItemModel } from '@umbraco-cms/backoffice/user';
 import type { UUIPaginationEvent } from '@umbraco-cms/backoffice/external/uui';
 
-const TimeOptions: Intl.DateTimeFormatOptions = {
-	year: 'numeric',
-	month: 'long',
-	day: 'numeric',
-	hour: 'numeric',
-	minute: 'numeric',
-	second: 'numeric',
-};
-
 @customElement('umb-content-audit-log-workspace-info-app')
 export class UmbContentAuditLogWorkspaceInfoAppElement extends UmbLitElement {
 	@property({ type: Object })
@@ -180,7 +171,9 @@ export class UmbContentAuditLogWorkspaceInfoAppElement extends UmbLitElement {
 		const user = this.#userMap.get(item.user.unique);
 
 		return html`
-			<umb-history-item .name=${user?.name ?? 'Unknown'} .detail=${this.localize.date(item.timestamp, TimeOptions)}>
+			<umb-history-item
+				.name=${user?.name ?? 'Unknown'}
+				.detail=${this.localize.date(item.timestamp, UMB_DATE_TIME_FORMAT_OPTIONS)}>
 				<umb-user-avatar slot="avatar" .name=${user?.name} .kind=${user?.kind} .imgUrls=${user?.avatarUrls ?? []}>
 				</umb-user-avatar>
 				<div class="log-type">
diff --git a/src/Umbraco.Web.UI.Client/src/packages/content/content/manager/content-data-manager.ts b/src/Umbraco.Web.UI.Client/src/packages/content/content/manager/content-data-manager.ts
index d74e000d98b2..418fbea98826 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/content/content/manager/content-data-manager.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/content/content/manager/content-data-manager.ts
@@ -150,7 +150,7 @@ export class UmbContentWorkspaceDataManager<
 		});
 
 		const changedProperties = current?.values.map((value) => {
-			const persistedValues = persisted?.values.find((x) => UmbVariantId.Create(value).compare(x));
+			const persistedValues = persisted?.values.find((x) => x.alias === value.alias && UmbVariantId.Create(value).compare(x));
 			return {
 				culture: value.culture,
 				segment: value.segment,
diff --git a/src/Umbraco.Web.UI.Client/src/packages/content/content/rollback/modal/content-rollback-modal.element.ts b/src/Umbraco.Web.UI.Client/src/packages/content/content/rollback/modal/content-rollback-modal.element.ts
index f1f8c2ceddcd..8e8ff9705bf4 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/content/content/rollback/modal/content-rollback-modal.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/content/content/rollback/modal/content-rollback-modal.element.ts
@@ -7,7 +7,7 @@ import { UmbModalBaseElement } from '@umbraco-cms/backoffice/modal';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
 import { UmbUserItemRepository } from '@umbraco-cms/backoffice/user';
 import { UMB_PROPERTY_DATASET_CONTEXT } from '@umbraco-cms/backoffice/property';
-import type { UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 import { UMB_APP_LANGUAGE_CONTEXT, UmbLanguageItemRepository } from '@umbraco-cms/backoffice/language';
 import { UMB_ENTITY_CONTEXT } from '@umbraco-cms/backoffice/entity';
 import { UmbVariantId } from '@umbraco-cms/backoffice/variant';
@@ -51,7 +51,7 @@ export class UmbContentRollbackModalElement extends UmbModalBaseElement<
 	private _isInvariant = true;
 
 	@state()
-	private _availableVariants: Array<Option> = [];
+	private _availableVariants: Array<UUISelectOption> = [];
 
 	@state()
 	private _diffs: Array<{ alias: string; diff: Array<UmbDiffChange> }> = [];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/content/content/workspace/content-detail-workspace-base.ts b/src/Umbraco.Web.UI.Client/src/packages/content/content/workspace/content-detail-workspace-base.ts
index 0be1c16c2df2..92e852de7159 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/content/content/workspace/content-detail-workspace-base.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/content/content/workspace/content-detail-workspace-base.ts
@@ -1114,7 +1114,9 @@ export abstract class UmbContentDetailWorkspaceContextBase<
 		const variantIdsIncludingInvariant = [...variantIds, UmbVariantId.CreateInvariant()];
 
 		// Only update the variants that was chosen to be saved:
-		const persistedData = this._data.getCurrent();
+		// Use getPersisted() as the base so non-saved variants retain the actual
+		// server state, not unsaved local edits from current data.
+		const persistedData = this._data.getPersisted();
 		const newPersistedData = await new UmbMergeContentVariantDataController(this).process(
 			persistedData,
 			data,
diff --git a/src/Umbraco.Web.UI.Client/src/packages/content/property-type/workspace/views/settings/property-workspace-view-settings.element.ts b/src/Umbraco.Web.UI.Client/src/packages/content/property-type/workspace/views/settings/property-workspace-view-settings.element.ts
index 4700a01782ac..e50b2697e4e3 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/content/property-type/workspace/views/settings/property-workspace-view-settings.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/content/property-type/workspace/views/settings/property-workspace-view-settings.element.ts
@@ -6,7 +6,12 @@ import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
 import { UMB_CONTENT_TYPE_WORKSPACE_CONTEXT } from '@umbraco-cms/backoffice/content-type';
 import type { UmbPropertyTypeScaffoldModel } from '@umbraco-cms/backoffice/content-type';
 import type { UmbWorkspaceViewElement } from '@umbraco-cms/backoffice/workspace';
-import type { UUIBooleanInputEvent, UUIInputEvent, UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type {
+	UUIBooleanInputEvent,
+	UUIInputEvent,
+	UUISelectEvent,
+	UUISelectOption,
+} from '@umbraco-cms/backoffice/external/uui';
 import type { UmbInputWithAliasElement } from '@umbraco-cms/backoffice/components';
 
 @customElement('umb-property-type-workspace-view-settings')
@@ -14,7 +19,7 @@ export class UmbPropertyTypeWorkspaceViewSettingsElement extends UmbLitElement i
 	#context?: typeof UMB_PROPERTY_TYPE_WORKSPACE_CONTEXT.TYPE;
 
 	@state()
-	private _customValidationOptions: Array<Option> = [
+	private _customValidationOptions: Array<UUISelectOption> = [
 		{
 			name: this.localize.term('validation_validateNothing'),
 			value: '!NOVALIDATION!',
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/backend-api/sdk.gen.ts b/src/Umbraco.Web.UI.Client/src/packages/core/backend-api/sdk.gen.ts
index b9dbad07b935..1e7ab1871eb4 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/backend-api/sdk.gen.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/backend-api/sdk.gen.ts
@@ -2,7 +2,7 @@
 
 import { type Client, formDataBodySerializer, type Options as Options2, type TDataShape } from './client';
 import { client } from './client.gen';
-import type { DeleteDataTypeByIdData, DeleteDataTypeByIdErrors, DeleteDataTypeByIdResponses, DeleteDataTypeFolderByIdData, DeleteDataTypeFolderByIdErrors, DeleteDataTypeFolderByIdResponses, DeleteDictionaryByIdData, DeleteDictionaryByIdErrors, DeleteDictionaryByIdResponses, DeleteDocumentBlueprintByIdData, DeleteDocumentBlueprintByIdErrors, DeleteDocumentBlueprintByIdResponses, DeleteDocumentBlueprintFolderByIdData, DeleteDocumentBlueprintFolderByIdErrors, DeleteDocumentBlueprintFolderByIdResponses, DeleteDocumentByIdData, DeleteDocumentByIdErrors, DeleteDocumentByIdPublicAccessData, DeleteDocumentByIdPublicAccessErrors, DeleteDocumentByIdPublicAccessResponses, DeleteDocumentByIdResponses, DeleteDocumentTypeByIdData, DeleteDocumentTypeByIdErrors, DeleteDocumentTypeByIdResponses, DeleteDocumentTypeFolderByIdData, DeleteDocumentTypeFolderByIdErrors, DeleteDocumentTypeFolderByIdResponses, DeleteElementByIdData, DeleteElementByIdErrors, DeleteElementByIdResponses, DeleteElementFolderByIdData, DeleteElementFolderByIdErrors, DeleteElementFolderByIdResponses, DeleteLanguageByIsoCodeData, DeleteLanguageByIsoCodeErrors, DeleteLanguageByIsoCodeResponses, DeleteLogViewerSavedSearchByNameData, DeleteLogViewerSavedSearchByNameErrors, DeleteLogViewerSavedSearchByNameResponses, DeleteMediaByIdData, DeleteMediaByIdErrors, DeleteMediaByIdResponses, DeleteMediaTypeByIdData, DeleteMediaTypeByIdErrors, DeleteMediaTypeByIdResponses, DeleteMediaTypeFolderByIdData, DeleteMediaTypeFolderByIdErrors, DeleteMediaTypeFolderByIdResponses, DeleteMemberByIdData, DeleteMemberByIdErrors, DeleteMemberByIdResponses, DeleteMemberGroupByIdData, DeleteMemberGroupByIdErrors, DeleteMemberGroupByIdResponses, DeleteMemberTypeByIdData, DeleteMemberTypeByIdErrors, DeleteMemberTypeByIdResponses, DeleteMemberTypeFolderByIdData, DeleteMemberTypeFolderByIdErrors, DeleteMemberTypeFolderByIdResponses, DeletePackageCreatedByIdData, DeletePackageCreatedByIdErrors, DeletePackageCreatedByIdResponses, DeletePartialViewByPathData, DeletePartialViewByPathErrors, DeletePartialViewByPathResponses, DeletePartialViewFolderByPathData, DeletePartialViewFolderByPathErrors, DeletePartialViewFolderByPathResponses, DeletePreviewData, DeletePreviewResponses, DeleteRecycleBinDocumentByIdData, DeleteRecycleBinDocumentByIdErrors, DeleteRecycleBinDocumentByIdResponses, DeleteRecycleBinDocumentData, DeleteRecycleBinDocumentErrors, DeleteRecycleBinDocumentResponses, DeleteRecycleBinElementByIdData, DeleteRecycleBinElementByIdErrors, DeleteRecycleBinElementByIdResponses, DeleteRecycleBinElementData, DeleteRecycleBinElementErrors, DeleteRecycleBinElementFolderByIdData, DeleteRecycleBinElementFolderByIdErrors, DeleteRecycleBinElementFolderByIdResponses, DeleteRecycleBinElementResponses, DeleteRecycleBinMediaByIdData, DeleteRecycleBinMediaByIdErrors, DeleteRecycleBinMediaByIdResponses, DeleteRecycleBinMediaData, DeleteRecycleBinMediaErrors, DeleteRecycleBinMediaResponses, DeleteRedirectManagementByIdData, DeleteRedirectManagementByIdErrors, DeleteRedirectManagementByIdResponses, DeleteScriptByPathData, DeleteScriptByPathErrors, DeleteScriptByPathResponses, DeleteScriptFolderByPathData, DeleteScriptFolderByPathErrors, DeleteScriptFolderByPathResponses, DeleteStylesheetByPathData, DeleteStylesheetByPathErrors, DeleteStylesheetByPathResponses, DeleteStylesheetFolderByPathData, DeleteStylesheetFolderByPathErrors, DeleteStylesheetFolderByPathResponses, DeleteTemplateByIdData, DeleteTemplateByIdErrors, DeleteTemplateByIdResponses, DeleteTemporaryFileByIdData, DeleteTemporaryFileByIdErrors, DeleteTemporaryFileByIdResponses, DeleteUserAvatarByIdData, DeleteUserAvatarByIdErrors, DeleteUserAvatarByIdResponses, DeleteUserById2FaByProviderNameData, DeleteUserById2FaByProviderNameErrors, DeleteUserById2FaByProviderNameResponses, DeleteUserByIdClientCredentialsByClientIdData, DeleteUserByIdClientCredentialsByClientIdErrors, DeleteUserByIdClientCredentialsByClientIdResponses, DeleteUserByIdData, DeleteUserByIdErrors, DeleteUserByIdResponses, DeleteUserCurrent2FaByProviderNameData, DeleteUserCurrent2FaByProviderNameErrors, DeleteUserCurrent2FaByProviderNameResponses, DeleteUserData, DeleteUserDataByIdData, DeleteUserDataByIdErrors, DeleteUserDataByIdResponses, DeleteUserErrors, DeleteUserGroupByIdData, DeleteUserGroupByIdErrors, DeleteUserGroupByIdResponses, DeleteUserGroupByIdUsersData, DeleteUserGroupByIdUsersErrors, DeleteUserGroupByIdUsersResponses, DeleteUserGroupData, DeleteUserGroupErrors, DeleteUserGroupResponses, DeleteUserResponses, DeleteWebhookByIdData, DeleteWebhookByIdErrors, DeleteWebhookByIdResponses, GetCollectionDocumentByIdData, GetCollectionDocumentByIdErrors, GetCollectionDocumentByIdResponses, GetCollectionMediaData, GetCollectionMediaErrors, GetCollectionMediaResponses, GetCultureData, GetCultureErrors, GetCultureResponses, GetDataTypeBatchData, GetDataTypeBatchErrors, GetDataTypeBatchResponses, GetDataTypeByIdData, GetDataTypeByIdErrors, GetDataTypeByIdIsUsedData, GetDataTypeByIdIsUsedErrors, GetDataTypeByIdIsUsedResponses, GetDataTypeByIdReferencedByData, GetDataTypeByIdReferencedByErrors, GetDataTypeByIdReferencedByResponses, GetDataTypeByIdResponses, GetDataTypeByIdSchemaData, GetDataTypeByIdSchemaErrors, GetDataTypeByIdSchemaResponses, GetDataTypeConfigurationData, GetDataTypeConfigurationErrors, GetDataTypeConfigurationResponses, GetDataTypeFolderByIdData, GetDataTypeFolderByIdErrors, GetDataTypeFolderByIdResponses, GetDataTypeSchemasBatchData, GetDataTypeSchemasBatchErrors, GetDataTypeSchemasBatchResponses, GetDictionaryByIdData, GetDictionaryByIdErrors, GetDictionaryByIdExportData, GetDictionaryByIdExportErrors, GetDictionaryByIdExportResponses, GetDictionaryByIdResponses, GetDictionaryData, GetDictionaryErrors, GetDictionaryResponses, GetDocumentAreReferencedData, GetDocumentAreReferencedErrors, GetDocumentAreReferencedResponses, GetDocumentBlueprintByIdData, GetDocumentBlueprintByIdErrors, GetDocumentBlueprintByIdResponses, GetDocumentBlueprintByIdScaffoldData, GetDocumentBlueprintByIdScaffoldErrors, GetDocumentBlueprintByIdScaffoldResponses, GetDocumentBlueprintFolderByIdData, GetDocumentBlueprintFolderByIdErrors, GetDocumentBlueprintFolderByIdResponses, GetDocumentByIdAuditLogData, GetDocumentByIdAuditLogErrors, GetDocumentByIdAuditLogResponses, GetDocumentByIdAvailableSegmentOptionsData, GetDocumentByIdAvailableSegmentOptionsErrors, GetDocumentByIdAvailableSegmentOptionsResponses, GetDocumentByIdData, GetDocumentByIdDomainsData, GetDocumentByIdDomainsErrors, GetDocumentByIdDomainsResponses, GetDocumentByIdErrors, GetDocumentByIdNotificationsData, GetDocumentByIdNotificationsErrors, GetDocumentByIdNotificationsResponses, GetDocumentByIdPreviewUrlData, GetDocumentByIdPreviewUrlErrors, GetDocumentByIdPreviewUrlResponses, GetDocumentByIdPublicAccessData, GetDocumentByIdPublicAccessErrors, GetDocumentByIdPublicAccessResponses, GetDocumentByIdPublishedData, GetDocumentByIdPublishedErrors, GetDocumentByIdPublishedResponses, GetDocumentByIdPublishWithDescendantsResultByTaskIdData, GetDocumentByIdPublishWithDescendantsResultByTaskIdErrors, GetDocumentByIdPublishWithDescendantsResultByTaskIdResponses, GetDocumentByIdReferencedByData, GetDocumentByIdReferencedByErrors, GetDocumentByIdReferencedByResponses, GetDocumentByIdReferencedDescendantsData, GetDocumentByIdReferencedDescendantsErrors, GetDocumentByIdReferencedDescendantsResponses, GetDocumentByIdResponses, GetDocumentConfigurationData, GetDocumentConfigurationErrors, GetDocumentConfigurationResponses, GetDocumentTypeAllowedAtRootData, GetDocumentTypeAllowedAtRootErrors, GetDocumentTypeAllowedAtRootResponses, GetDocumentTypeAllowedInLibraryData, GetDocumentTypeAllowedInLibraryErrors, GetDocumentTypeAllowedInLibraryResponses, GetDocumentTypeBatchData, GetDocumentTypeBatchErrors, GetDocumentTypeBatchResponses, GetDocumentTypeByIdAllowedChildrenData, GetDocumentTypeByIdAllowedChildrenErrors, GetDocumentTypeByIdAllowedChildrenResponses, GetDocumentTypeByIdAllowedParentsData, GetDocumentTypeByIdAllowedParentsErrors, GetDocumentTypeByIdAllowedParentsResponses, GetDocumentTypeByIdBlueprintData, GetDocumentTypeByIdBlueprintErrors, GetDocumentTypeByIdBlueprintResponses, GetDocumentTypeByIdCompositionReferencesData, GetDocumentTypeByIdCompositionReferencesErrors, GetDocumentTypeByIdCompositionReferencesResponses, GetDocumentTypeByIdData, GetDocumentTypeByIdErrors, GetDocumentTypeByIdExportData, GetDocumentTypeByIdExportErrors, GetDocumentTypeByIdExportResponses, GetDocumentTypeByIdResponses, GetDocumentTypeByIdSchemaData, GetDocumentTypeByIdSchemaErrors, GetDocumentTypeByIdSchemaResponses, GetDocumentTypeConfigurationData, GetDocumentTypeConfigurationErrors, GetDocumentTypeConfigurationResponses, GetDocumentTypeFolderByIdData, GetDocumentTypeFolderByIdErrors, GetDocumentTypeFolderByIdResponses, GetDocumentUrlsData, GetDocumentUrlsErrors, GetDocumentUrlsResponses, GetDocumentVersionByIdData, GetDocumentVersionByIdErrors, GetDocumentVersionByIdResponses, GetDocumentVersionData, GetDocumentVersionErrors, GetDocumentVersionResponses, GetDynamicRootStepsData, GetDynamicRootStepsErrors, GetDynamicRootStepsResponses, GetElementAreReferencedData, GetElementAreReferencedErrors, GetElementAreReferencedResponses, GetElementByIdAuditLogData, GetElementByIdAuditLogErrors, GetElementByIdAuditLogResponses, GetElementByIdData, GetElementByIdErrors, GetElementByIdReferencedByData, GetElementByIdReferencedByErrors, GetElementByIdReferencedByResponses, GetElementByIdResponses, GetElementConfigurationData, GetElementConfigurationErrors, GetElementConfigurationResponses, GetElementFolderByIdData, GetElementFolderByIdErrors, GetElementFolderByIdReferencedDescendantsData, GetElementFolderByIdReferencedDescendantsErrors, GetElementFolderByIdReferencedDescendantsResponses, GetElementFolderByIdResponses, GetElementVersionByIdData, GetElementVersionByIdErrors, GetElementVersionByIdResponses, GetElementVersionData, GetElementVersionErrors, GetElementVersionResponses, GetFilterDataTypeData, GetFilterDataTypeErrors, GetFilterDataTypeResponses, GetFilterMemberData, GetFilterMemberErrors, GetFilterMemberResponses, GetFilterUserData, GetFilterUserErrors, GetFilterUserGroupData, GetFilterUserGroupErrors, GetFilterUserGroupResponses, GetFilterUserResponses, GetHealthCheckGroupByNameData, GetHealthCheckGroupByNameErrors, GetHealthCheckGroupByNameResponses, GetHealthCheckGroupData, GetHealthCheckGroupErrors, GetHealthCheckGroupResponses, GetHelpData, GetHelpErrors, GetHelpResponses, GetImagingResizeUrlsData, GetImagingResizeUrlsErrors, GetImagingResizeUrlsResponses, GetImportAnalyzeData, GetImportAnalyzeErrors, GetImportAnalyzeResponses, GetIndexerByIndexNameData, GetIndexerByIndexNameErrors, GetIndexerByIndexNameResponses, GetIndexerData, GetIndexerErrors, GetIndexerResponses, GetInstallSettingsData, GetInstallSettingsErrors, GetInstallSettingsResponses, GetItemDataTypeAncestorsData, GetItemDataTypeAncestorsErrors, GetItemDataTypeAncestorsResponses, GetItemDataTypeData, GetItemDataTypeErrors, GetItemDataTypeResponses, GetItemDataTypeSearchData, GetItemDataTypeSearchErrors, GetItemDataTypeSearchResponses, GetItemDictionaryData, GetItemDictionaryErrors, GetItemDictionaryResponses, GetItemDocumentAncestorsData, GetItemDocumentAncestorsErrors, GetItemDocumentAncestorsResponses, GetItemDocumentBlueprintData, GetItemDocumentBlueprintErrors, GetItemDocumentBlueprintResponses, GetItemDocumentData, GetItemDocumentErrors, GetItemDocumentResponses, GetItemDocumentSearchData, GetItemDocumentSearchErrors, GetItemDocumentSearchResponses, GetItemDocumentTypeAncestorsData, GetItemDocumentTypeAncestorsErrors, GetItemDocumentTypeAncestorsResponses, GetItemDocumentTypeData, GetItemDocumentTypeErrors, GetItemDocumentTypeResponses, GetItemDocumentTypeSearchData, GetItemDocumentTypeSearchErrors, GetItemDocumentTypeSearchResponses, GetItemElementData, GetItemElementErrors, GetItemElementFolderData, GetItemElementFolderErrors, GetItemElementFolderResponses, GetItemElementResponses, GetItemLanguageData, GetItemLanguageDefaultData, GetItemLanguageDefaultErrors, GetItemLanguageDefaultResponses, GetItemLanguageErrors, GetItemLanguageResponses, GetItemMediaAncestorsData, GetItemMediaAncestorsErrors, GetItemMediaAncestorsResponses, GetItemMediaData, GetItemMediaErrors, GetItemMediaResponses, GetItemMediaSearchData, GetItemMediaSearchErrors, GetItemMediaSearchResponses, GetItemMediaTypeAllowedData, GetItemMediaTypeAllowedErrors, GetItemMediaTypeAllowedResponses, GetItemMediaTypeAncestorsData, GetItemMediaTypeAncestorsErrors, GetItemMediaTypeAncestorsResponses, GetItemMediaTypeData, GetItemMediaTypeErrors, GetItemMediaTypeFoldersData, GetItemMediaTypeFoldersErrors, GetItemMediaTypeFoldersResponses, GetItemMediaTypeResponses, GetItemMediaTypeSearchData, GetItemMediaTypeSearchErrors, GetItemMediaTypeSearchResponses, GetItemMemberAncestorsData, GetItemMemberAncestorsErrors, GetItemMemberAncestorsResponses, GetItemMemberData, GetItemMemberErrors, GetItemMemberGroupData, GetItemMemberGroupErrors, GetItemMemberGroupResponses, GetItemMemberResponses, GetItemMemberSearchData, GetItemMemberSearchErrors, GetItemMemberSearchResponses, GetItemMemberTypeAncestorsData, GetItemMemberTypeAncestorsErrors, GetItemMemberTypeAncestorsResponses, GetItemMemberTypeData, GetItemMemberTypeErrors, GetItemMemberTypeResponses, GetItemMemberTypeSearchData, GetItemMemberTypeSearchErrors, GetItemMemberTypeSearchResponses, GetItemPartialViewData, GetItemPartialViewErrors, GetItemPartialViewResponses, GetItemRelationTypeData, GetItemRelationTypeErrors, GetItemRelationTypeResponses, GetItemScriptData, GetItemScriptErrors, GetItemScriptResponses, GetItemStaticFileData, GetItemStaticFileErrors, GetItemStaticFileResponses, GetItemStylesheetData, GetItemStylesheetErrors, GetItemStylesheetResponses, GetItemTemplateAncestorsData, GetItemTemplateAncestorsErrors, GetItemTemplateAncestorsResponses, GetItemTemplateData, GetItemTemplateErrors, GetItemTemplateResponses, GetItemTemplateSearchData, GetItemTemplateSearchErrors, GetItemTemplateSearchResponses, GetItemUserData, GetItemUserErrors, GetItemUserGroupData, GetItemUserGroupErrors, GetItemUserGroupResponses, GetItemUserResponses, GetItemWebhookData, GetItemWebhookErrors, GetItemWebhookResponses, GetLanguageByIsoCodeData, GetLanguageByIsoCodeErrors, GetLanguageByIsoCodeResponses, GetLanguageData, GetLanguageErrors, GetLanguageResponses, GetLogViewerLevelCountData, GetLogViewerLevelCountErrors, GetLogViewerLevelCountResponses, GetLogViewerLevelData, GetLogViewerLevelErrors, GetLogViewerLevelResponses, GetLogViewerLogData, GetLogViewerLogErrors, GetLogViewerLogResponses, GetLogViewerMessageTemplateData, GetLogViewerMessageTemplateErrors, GetLogViewerMessageTemplateResponses, GetLogViewerSavedSearchByNameData, GetLogViewerSavedSearchByNameErrors, GetLogViewerSavedSearchByNameResponses, GetLogViewerSavedSearchData, GetLogViewerSavedSearchErrors, GetLogViewerSavedSearchResponses, GetLogViewerValidateLogsSizeData, GetLogViewerValidateLogsSizeErrors, GetLogViewerValidateLogsSizeResponses, GetManifestManifestData, GetManifestManifestErrors, GetManifestManifestPrivateData, GetManifestManifestPrivateErrors, GetManifestManifestPrivateResponses, GetManifestManifestPublicData, GetManifestManifestPublicResponses, GetManifestManifestResponses, GetMediaAreReferencedData, GetMediaAreReferencedErrors, GetMediaAreReferencedResponses, GetMediaByIdAuditLogData, GetMediaByIdAuditLogErrors, GetMediaByIdAuditLogResponses, GetMediaByIdData, GetMediaByIdErrors, GetMediaByIdReferencedByData, GetMediaByIdReferencedByErrors, GetMediaByIdReferencedByResponses, GetMediaByIdReferencedDescendantsData, GetMediaByIdReferencedDescendantsErrors, GetMediaByIdReferencedDescendantsResponses, GetMediaByIdResponses, GetMediaConfigurationData, GetMediaConfigurationErrors, GetMediaConfigurationResponses, GetMediaTypeAllowedAtRootData, GetMediaTypeAllowedAtRootErrors, GetMediaTypeAllowedAtRootResponses, GetMediaTypeBatchData, GetMediaTypeBatchErrors, GetMediaTypeBatchResponses, GetMediaTypeByIdAllowedChildrenData, GetMediaTypeByIdAllowedChildrenErrors, GetMediaTypeByIdAllowedChildrenResponses, GetMediaTypeByIdAllowedParentsData, GetMediaTypeByIdAllowedParentsErrors, GetMediaTypeByIdAllowedParentsResponses, GetMediaTypeByIdCompositionReferencesData, GetMediaTypeByIdCompositionReferencesErrors, GetMediaTypeByIdCompositionReferencesResponses, GetMediaTypeByIdData, GetMediaTypeByIdErrors, GetMediaTypeByIdExportData, GetMediaTypeByIdExportErrors, GetMediaTypeByIdExportResponses, GetMediaTypeByIdResponses, GetMediaTypeByIdSchemaData, GetMediaTypeByIdSchemaErrors, GetMediaTypeByIdSchemaResponses, GetMediaTypeConfigurationData, GetMediaTypeConfigurationErrors, GetMediaTypeConfigurationResponses, GetMediaTypeFolderByIdData, GetMediaTypeFolderByIdErrors, GetMediaTypeFolderByIdResponses, GetMediaUrlsData, GetMediaUrlsErrors, GetMediaUrlsResponses, GetMemberAreReferencedData, GetMemberAreReferencedErrors, GetMemberAreReferencedResponses, GetMemberByIdData, GetMemberByIdErrors, GetMemberByIdReferencedByData, GetMemberByIdReferencedByErrors, GetMemberByIdReferencedByResponses, GetMemberByIdReferencedDescendantsData, GetMemberByIdReferencedDescendantsErrors, GetMemberByIdReferencedDescendantsResponses, GetMemberByIdResponses, GetMemberConfigurationData, GetMemberConfigurationErrors, GetMemberConfigurationResponses, GetMemberGroupByIdData, GetMemberGroupByIdErrors, GetMemberGroupByIdResponses, GetMemberGroupData, GetMemberGroupErrors, GetMemberGroupResponses, GetMemberTypeAllowedAtRootData, GetMemberTypeAllowedAtRootErrors, GetMemberTypeAllowedAtRootResponses, GetMemberTypeBatchData, GetMemberTypeBatchErrors, GetMemberTypeBatchResponses, GetMemberTypeByIdCompositionReferencesData, GetMemberTypeByIdCompositionReferencesErrors, GetMemberTypeByIdCompositionReferencesResponses, GetMemberTypeByIdData, GetMemberTypeByIdErrors, GetMemberTypeByIdExportData, GetMemberTypeByIdExportErrors, GetMemberTypeByIdExportResponses, GetMemberTypeByIdResponses, GetMemberTypeByIdSchemaData, GetMemberTypeByIdSchemaErrors, GetMemberTypeByIdSchemaResponses, GetMemberTypeConfigurationData, GetMemberTypeConfigurationErrors, GetMemberTypeConfigurationResponses, GetMemberTypeFolderByIdData, GetMemberTypeFolderByIdErrors, GetMemberTypeFolderByIdResponses, GetModelsBuilderDashboardData, GetModelsBuilderDashboardErrors, GetModelsBuilderDashboardResponses, GetModelsBuilderStatusData, GetModelsBuilderStatusErrors, GetModelsBuilderStatusResponses, GetNewsDashboardData, GetNewsDashboardErrors, GetNewsDashboardResponses, GetObjectTypesData, GetObjectTypesErrors, GetObjectTypesResponses, GetOembedQueryData, GetOembedQueryErrors, GetOembedQueryResponses, GetPackageConfigurationData, GetPackageConfigurationErrors, GetPackageConfigurationResponses, GetPackageCreatedByIdData, GetPackageCreatedByIdDownloadData, GetPackageCreatedByIdDownloadErrors, GetPackageCreatedByIdDownloadResponses, GetPackageCreatedByIdErrors, GetPackageCreatedByIdResponses, GetPackageCreatedData, GetPackageCreatedErrors, GetPackageCreatedResponses, GetPackageMigrationStatusData, GetPackageMigrationStatusErrors, GetPackageMigrationStatusResponses, GetPartialViewByPathData, GetPartialViewByPathErrors, GetPartialViewByPathResponses, GetPartialViewFolderByPathData, GetPartialViewFolderByPathErrors, GetPartialViewFolderByPathResponses, GetPartialViewSnippetByIdData, GetPartialViewSnippetByIdErrors, GetPartialViewSnippetByIdResponses, GetPartialViewSnippetData, GetPartialViewSnippetErrors, GetPartialViewSnippetResponses, GetProfilingStatusData, GetProfilingStatusErrors, GetProfilingStatusResponses, GetPropertyTypeIsUsedData, GetPropertyTypeIsUsedErrors, GetPropertyTypeIsUsedResponses, GetPublishedCacheRebuildStatusData, GetPublishedCacheRebuildStatusErrors, GetPublishedCacheRebuildStatusResponses, GetRecycleBinDocumentByIdOriginalParentData, GetRecycleBinDocumentByIdOriginalParentErrors, GetRecycleBinDocumentByIdOriginalParentResponses, GetRecycleBinDocumentChildrenData, GetRecycleBinDocumentChildrenErrors, GetRecycleBinDocumentChildrenResponses, GetRecycleBinDocumentReferencedByData, GetRecycleBinDocumentReferencedByErrors, GetRecycleBinDocumentReferencedByResponses, GetRecycleBinDocumentRootData, GetRecycleBinDocumentRootErrors, GetRecycleBinDocumentRootResponses, GetRecycleBinDocumentSiblingsData, GetRecycleBinDocumentSiblingsErrors, GetRecycleBinDocumentSiblingsResponses, GetRecycleBinElementByIdOriginalParentData, GetRecycleBinElementByIdOriginalParentErrors, GetRecycleBinElementByIdOriginalParentResponses, GetRecycleBinElementChildrenData, GetRecycleBinElementChildrenErrors, GetRecycleBinElementChildrenResponses, GetRecycleBinElementFolderByIdOriginalParentData, GetRecycleBinElementFolderByIdOriginalParentErrors, GetRecycleBinElementFolderByIdOriginalParentResponses, GetRecycleBinElementReferencedByData, GetRecycleBinElementReferencedByErrors, GetRecycleBinElementReferencedByResponses, GetRecycleBinElementRootData, GetRecycleBinElementRootErrors, GetRecycleBinElementRootResponses, GetRecycleBinElementSiblingsData, GetRecycleBinElementSiblingsErrors, GetRecycleBinElementSiblingsResponses, GetRecycleBinMediaByIdOriginalParentData, GetRecycleBinMediaByIdOriginalParentErrors, GetRecycleBinMediaByIdOriginalParentResponses, GetRecycleBinMediaChildrenData, GetRecycleBinMediaChildrenErrors, GetRecycleBinMediaChildrenResponses, GetRecycleBinMediaReferencedByData, GetRecycleBinMediaReferencedByErrors, GetRecycleBinMediaReferencedByResponses, GetRecycleBinMediaRootData, GetRecycleBinMediaRootErrors, GetRecycleBinMediaRootResponses, GetRecycleBinMediaSiblingsData, GetRecycleBinMediaSiblingsErrors, GetRecycleBinMediaSiblingsResponses, GetRedirectManagementByIdData, GetRedirectManagementByIdErrors, GetRedirectManagementByIdResponses, GetRedirectManagementData, GetRedirectManagementErrors, GetRedirectManagementResponses, GetRedirectManagementStatusData, GetRedirectManagementStatusErrors, GetRedirectManagementStatusResponses, GetRelationByRelationTypeIdData, GetRelationByRelationTypeIdErrors, GetRelationByRelationTypeIdResponses, GetRelationTypeByIdData, GetRelationTypeByIdErrors, GetRelationTypeByIdResponses, GetRelationTypeData, GetRelationTypeErrors, GetRelationTypeResponses, GetScriptByPathData, GetScriptByPathErrors, GetScriptByPathResponses, GetScriptFolderByPathData, GetScriptFolderByPathErrors, GetScriptFolderByPathResponses, GetSearcherBySearcherNameQueryData, GetSearcherBySearcherNameQueryErrors, GetSearcherBySearcherNameQueryResponses, GetSearcherData, GetSearcherErrors, GetSearcherResponses, GetSecurityConfigurationData, GetSecurityConfigurationErrors, GetSecurityConfigurationResponses, GetSegmentData, GetSegmentErrors, GetSegmentResponses, GetServerConfigurationData, GetServerConfigurationResponses, GetServerInformationData, GetServerInformationErrors, GetServerInformationResponses, GetServerStatusData, GetServerStatusErrors, GetServerStatusResponses, GetServerTroubleshootingData, GetServerTroubleshootingErrors, GetServerTroubleshootingResponses, GetServerUpgradeCheckData, GetServerUpgradeCheckErrors, GetServerUpgradeCheckResponses, GetStylesheetByPathData, GetStylesheetByPathErrors, GetStylesheetByPathResponses, GetStylesheetFolderByPathData, GetStylesheetFolderByPathErrors, GetStylesheetFolderByPathResponses, GetTagData, GetTagErrors, GetTagResponses, GetTelemetryData, GetTelemetryErrors, GetTelemetryLevelData, GetTelemetryLevelErrors, GetTelemetryLevelResponses, GetTelemetryResponses, GetTemplateByIdData, GetTemplateByIdErrors, GetTemplateByIdResponses, GetTemplateConfigurationData, GetTemplateConfigurationErrors, GetTemplateConfigurationResponses, GetTemplateQuerySettingsData, GetTemplateQuerySettingsErrors, GetTemplateQuerySettingsResponses, GetTemporaryFileByIdData, GetTemporaryFileByIdErrors, GetTemporaryFileByIdResponses, GetTemporaryFileConfigurationData, GetTemporaryFileConfigurationErrors, GetTemporaryFileConfigurationResponses, GetTreeDataTypeAncestorsData, GetTreeDataTypeAncestorsErrors, GetTreeDataTypeAncestorsResponses, GetTreeDataTypeChildrenData, GetTreeDataTypeChildrenErrors, GetTreeDataTypeChildrenResponses, GetTreeDataTypeRootData, GetTreeDataTypeRootErrors, GetTreeDataTypeRootResponses, GetTreeDataTypeSearchData, GetTreeDataTypeSearchErrors, GetTreeDataTypeSearchResponses, GetTreeDataTypeSiblingsData, GetTreeDataTypeSiblingsErrors, GetTreeDataTypeSiblingsResponses, GetTreeDictionaryAncestorsData, GetTreeDictionaryAncestorsErrors, GetTreeDictionaryAncestorsResponses, GetTreeDictionaryChildrenData, GetTreeDictionaryChildrenErrors, GetTreeDictionaryChildrenResponses, GetTreeDictionaryRootData, GetTreeDictionaryRootErrors, GetTreeDictionaryRootResponses, GetTreeDocumentAncestorsData, GetTreeDocumentAncestorsErrors, GetTreeDocumentAncestorsResponses, GetTreeDocumentBlueprintAncestorsData, GetTreeDocumentBlueprintAncestorsErrors, GetTreeDocumentBlueprintAncestorsResponses, GetTreeDocumentBlueprintChildrenData, GetTreeDocumentBlueprintChildrenErrors, GetTreeDocumentBlueprintChildrenResponses, GetTreeDocumentBlueprintRootData, GetTreeDocumentBlueprintRootErrors, GetTreeDocumentBlueprintRootResponses, GetTreeDocumentBlueprintSiblingsData, GetTreeDocumentBlueprintSiblingsErrors, GetTreeDocumentBlueprintSiblingsResponses, GetTreeDocumentChildrenData, GetTreeDocumentChildrenErrors, GetTreeDocumentChildrenResponses, GetTreeDocumentRootData, GetTreeDocumentRootErrors, GetTreeDocumentRootResponses, GetTreeDocumentSiblingsData, GetTreeDocumentSiblingsErrors, GetTreeDocumentSiblingsResponses, GetTreeDocumentTypeAncestorsData, GetTreeDocumentTypeAncestorsErrors, GetTreeDocumentTypeAncestorsResponses, GetTreeDocumentTypeChildrenData, GetTreeDocumentTypeChildrenErrors, GetTreeDocumentTypeChildrenResponses, GetTreeDocumentTypeRootData, GetTreeDocumentTypeRootErrors, GetTreeDocumentTypeRootResponses, GetTreeDocumentTypeSearchData, GetTreeDocumentTypeSearchErrors, GetTreeDocumentTypeSearchResponses, GetTreeDocumentTypeSiblingsData, GetTreeDocumentTypeSiblingsErrors, GetTreeDocumentTypeSiblingsResponses, GetTreeElementAncestorsData, GetTreeElementAncestorsErrors, GetTreeElementAncestorsResponses, GetTreeElementChildrenData, GetTreeElementChildrenErrors, GetTreeElementChildrenResponses, GetTreeElementRootData, GetTreeElementRootErrors, GetTreeElementRootResponses, GetTreeElementSiblingsData, GetTreeElementSiblingsErrors, GetTreeElementSiblingsResponses, GetTreeMediaAncestorsData, GetTreeMediaAncestorsErrors, GetTreeMediaAncestorsResponses, GetTreeMediaChildrenData, GetTreeMediaChildrenErrors, GetTreeMediaChildrenResponses, GetTreeMediaRootData, GetTreeMediaRootErrors, GetTreeMediaRootResponses, GetTreeMediaSiblingsData, GetTreeMediaSiblingsErrors, GetTreeMediaSiblingsResponses, GetTreeMediaTypeAncestorsData, GetTreeMediaTypeAncestorsErrors, GetTreeMediaTypeAncestorsResponses, GetTreeMediaTypeChildrenData, GetTreeMediaTypeChildrenErrors, GetTreeMediaTypeChildrenResponses, GetTreeMediaTypeRootData, GetTreeMediaTypeRootErrors, GetTreeMediaTypeRootResponses, GetTreeMediaTypeSiblingsData, GetTreeMediaTypeSiblingsErrors, GetTreeMediaTypeSiblingsResponses, GetTreeMemberGroupRootData, GetTreeMemberGroupRootErrors, GetTreeMemberGroupRootResponses, GetTreeMemberTypeAncestorsData, GetTreeMemberTypeAncestorsErrors, GetTreeMemberTypeAncestorsResponses, GetTreeMemberTypeChildrenData, GetTreeMemberTypeChildrenErrors, GetTreeMemberTypeChildrenResponses, GetTreeMemberTypeRootData, GetTreeMemberTypeRootErrors, GetTreeMemberTypeRootResponses, GetTreeMemberTypeSiblingsData, GetTreeMemberTypeSiblingsErrors, GetTreeMemberTypeSiblingsResponses, GetTreePartialViewAncestorsData, GetTreePartialViewAncestorsErrors, GetTreePartialViewAncestorsResponses, GetTreePartialViewChildrenData, GetTreePartialViewChildrenErrors, GetTreePartialViewChildrenResponses, GetTreePartialViewRootData, GetTreePartialViewRootErrors, GetTreePartialViewRootResponses, GetTreePartialViewSiblingsData, GetTreePartialViewSiblingsErrors, GetTreePartialViewSiblingsResponses, GetTreeScriptAncestorsData, GetTreeScriptAncestorsErrors, GetTreeScriptAncestorsResponses, GetTreeScriptChildrenData, GetTreeScriptChildrenErrors, GetTreeScriptChildrenResponses, GetTreeScriptRootData, GetTreeScriptRootErrors, GetTreeScriptRootResponses, GetTreeScriptSiblingsData, GetTreeScriptSiblingsErrors, GetTreeScriptSiblingsResponses, GetTreeStaticFileAncestorsData, GetTreeStaticFileAncestorsErrors, GetTreeStaticFileAncestorsResponses, GetTreeStaticFileChildrenData, GetTreeStaticFileChildrenErrors, GetTreeStaticFileChildrenResponses, GetTreeStaticFileRootData, GetTreeStaticFileRootErrors, GetTreeStaticFileRootResponses, GetTreeStylesheetAncestorsData, GetTreeStylesheetAncestorsErrors, GetTreeStylesheetAncestorsResponses, GetTreeStylesheetChildrenData, GetTreeStylesheetChildrenErrors, GetTreeStylesheetChildrenResponses, GetTreeStylesheetRootData, GetTreeStylesheetRootErrors, GetTreeStylesheetRootResponses, GetTreeStylesheetSiblingsData, GetTreeStylesheetSiblingsErrors, GetTreeStylesheetSiblingsResponses, GetTreeTemplateAncestorsData, GetTreeTemplateAncestorsErrors, GetTreeTemplateAncestorsResponses, GetTreeTemplateChildrenData, GetTreeTemplateChildrenErrors, GetTreeTemplateChildrenResponses, GetTreeTemplateRootData, GetTreeTemplateRootErrors, GetTreeTemplateRootResponses, GetTreeTemplateSiblingsData, GetTreeTemplateSiblingsErrors, GetTreeTemplateSiblingsResponses, GetUpgradeSettingsData, GetUpgradeSettingsErrors, GetUpgradeSettingsResponses, GetUserById2FaData, GetUserById2FaErrors, GetUserById2FaResponses, GetUserByIdCalculateStartNodesData, GetUserByIdCalculateStartNodesErrors, GetUserByIdCalculateStartNodesResponses, GetUserByIdClientCredentialsData, GetUserByIdClientCredentialsErrors, GetUserByIdClientCredentialsResponses, GetUserByIdData, GetUserByIdErrors, GetUserByIdResponses, GetUserConfigurationData, GetUserConfigurationErrors, GetUserConfigurationResponses, GetUserCurrent2FaByProviderNameData, GetUserCurrent2FaByProviderNameErrors, GetUserCurrent2FaByProviderNameResponses, GetUserCurrent2FaData, GetUserCurrent2FaErrors, GetUserCurrent2FaResponses, GetUserCurrentConfigurationData, GetUserCurrentConfigurationErrors, GetUserCurrentConfigurationResponses, GetUserCurrentData, GetUserCurrentErrors, GetUserCurrentLoginProvidersData, GetUserCurrentLoginProvidersErrors, GetUserCurrentLoginProvidersResponses, GetUserCurrentPermissionsData, GetUserCurrentPermissionsDocumentData, GetUserCurrentPermissionsDocumentErrors, GetUserCurrentPermissionsDocumentResponses, GetUserCurrentPermissionsElementData, GetUserCurrentPermissionsElementErrors, GetUserCurrentPermissionsElementResponses, GetUserCurrentPermissionsErrors, GetUserCurrentPermissionsMediaData, GetUserCurrentPermissionsMediaErrors, GetUserCurrentPermissionsMediaResponses, GetUserCurrentPermissionsResponses, GetUserCurrentResponses, GetUserData, GetUserDataByIdData, GetUserDataByIdErrors, GetUserDataByIdResponses, GetUserDataData, GetUserDataErrors, GetUserDataResponses, GetUserErrors, GetUserGroupByIdData, GetUserGroupByIdErrors, GetUserGroupByIdResponses, GetUserGroupData, GetUserGroupErrors, GetUserGroupResponses, GetUserResponses, GetWebhookByIdData, GetWebhookByIdErrors, GetWebhookByIdLogsData, GetWebhookByIdLogsErrors, GetWebhookByIdLogsResponses, GetWebhookByIdResponses, GetWebhookData, GetWebhookErrors, GetWebhookEventsData, GetWebhookEventsErrors, GetWebhookEventsResponses, GetWebhookLogsData, GetWebhookLogsErrors, GetWebhookLogsResponses, GetWebhookResponses, PostDataTypeByIdCopyData, PostDataTypeByIdCopyErrors, PostDataTypeByIdCopyResponses, PostDataTypeData, PostDataTypeErrors, PostDataTypeFolderData, PostDataTypeFolderErrors, PostDataTypeFolderResponses, PostDataTypeResponses, PostDictionaryData, PostDictionaryErrors, PostDictionaryImportData, PostDictionaryImportErrors, PostDictionaryImportResponses, PostDictionaryResponses, PostDocumentBlueprintData, PostDocumentBlueprintErrors, PostDocumentBlueprintFolderData, PostDocumentBlueprintFolderErrors, PostDocumentBlueprintFolderResponses, PostDocumentBlueprintFromDocumentData, PostDocumentBlueprintFromDocumentErrors, PostDocumentBlueprintFromDocumentResponses, PostDocumentBlueprintResponses, PostDocumentByIdCopyData, PostDocumentByIdCopyErrors, PostDocumentByIdCopyResponses, PostDocumentByIdPublicAccessData, PostDocumentByIdPublicAccessErrors, PostDocumentByIdPublicAccessResponses, PostDocumentData, PostDocumentErrors, PostDocumentResponses, PostDocumentTypeAvailableCompositionsData, PostDocumentTypeAvailableCompositionsErrors, PostDocumentTypeAvailableCompositionsResponses, PostDocumentTypeByIdCopyData, PostDocumentTypeByIdCopyErrors, PostDocumentTypeByIdCopyResponses, PostDocumentTypeByIdTemplateData, PostDocumentTypeByIdTemplateErrors, PostDocumentTypeByIdTemplateResponses, PostDocumentTypeData, PostDocumentTypeErrors, PostDocumentTypeFolderData, PostDocumentTypeFolderErrors, PostDocumentTypeFolderResponses, PostDocumentTypeImportData, PostDocumentTypeImportErrors, PostDocumentTypeImportResponses, PostDocumentTypeResponses, PostDocumentValidateData, PostDocumentValidateErrors, PostDocumentValidateResponses, PostDocumentVersionByIdRollbackData, PostDocumentVersionByIdRollbackErrors, PostDocumentVersionByIdRollbackResponses, PostDynamicRootQueryData, PostDynamicRootQueryErrors, PostDynamicRootQueryResponses, PostElementByIdCopyData, PostElementByIdCopyErrors, PostElementByIdCopyResponses, PostElementData, PostElementErrors, PostElementFolderData, PostElementFolderErrors, PostElementFolderResponses, PostElementResponses, PostElementValidateData, PostElementValidateErrors, PostElementValidateResponses, PostElementVersionByIdRollbackData, PostElementVersionByIdRollbackErrors, PostElementVersionByIdRollbackResponses, PostHealthCheckExecuteActionData, PostHealthCheckExecuteActionErrors, PostHealthCheckExecuteActionResponses, PostHealthCheckGroupByNameCheckData, PostHealthCheckGroupByNameCheckErrors, PostHealthCheckGroupByNameCheckResponses, PostIndexerByIndexNameRebuildData, PostIndexerByIndexNameRebuildErrors, PostIndexerByIndexNameRebuildResponses, PostInstallSetupData, PostInstallSetupErrors, PostInstallSetupResponses, PostInstallValidateDatabaseData, PostInstallValidateDatabaseErrors, PostInstallValidateDatabaseResponses, PostLanguageData, PostLanguageErrors, PostLanguageResponses, PostLogViewerSavedSearchData, PostLogViewerSavedSearchErrors, PostLogViewerSavedSearchResponses, PostMediaData, PostMediaErrors, PostMediaResponses, PostMediaTypeAvailableCompositionsData, PostMediaTypeAvailableCompositionsErrors, PostMediaTypeAvailableCompositionsResponses, PostMediaTypeByIdCopyData, PostMediaTypeByIdCopyErrors, PostMediaTypeByIdCopyResponses, PostMediaTypeData, PostMediaTypeErrors, PostMediaTypeFolderData, PostMediaTypeFolderErrors, PostMediaTypeFolderResponses, PostMediaTypeImportData, PostMediaTypeImportErrors, PostMediaTypeImportResponses, PostMediaTypeResponses, PostMediaValidateData, PostMediaValidateErrors, PostMediaValidateResponses, PostMemberData, PostMemberErrors, PostMemberGroupData, PostMemberGroupErrors, PostMemberGroupResponses, PostMemberResponses, PostMemberTypeAvailableCompositionsData, PostMemberTypeAvailableCompositionsErrors, PostMemberTypeAvailableCompositionsResponses, PostMemberTypeByIdCopyData, PostMemberTypeByIdCopyErrors, PostMemberTypeByIdCopyResponses, PostMemberTypeData, PostMemberTypeErrors, PostMemberTypeFolderData, PostMemberTypeFolderErrors, PostMemberTypeFolderResponses, PostMemberTypeImportData, PostMemberTypeImportErrors, PostMemberTypeImportResponses, PostMemberTypeResponses, PostMemberValidateData, PostMemberValidateErrors, PostMemberValidateResponses, PostModelsBuilderBuildData, PostModelsBuilderBuildErrors, PostModelsBuilderBuildResponses, PostPackageByNameRunMigrationData, PostPackageByNameRunMigrationErrors, PostPackageByNameRunMigrationResponses, PostPackageCreatedData, PostPackageCreatedErrors, PostPackageCreatedResponses, PostPartialViewData, PostPartialViewErrors, PostPartialViewFolderData, PostPartialViewFolderErrors, PostPartialViewFolderResponses, PostPartialViewResponses, PostPublishedCacheRebuildData, PostPublishedCacheRebuildErrors, PostPublishedCacheRebuildResponses, PostPublishedCacheReloadData, PostPublishedCacheReloadErrors, PostPublishedCacheReloadResponses, PostRedirectManagementStatusData, PostRedirectManagementStatusErrors, PostRedirectManagementStatusResponses, PostScriptData, PostScriptErrors, PostScriptFolderData, PostScriptFolderErrors, PostScriptFolderResponses, PostScriptResponses, PostSecurityForgotPasswordData, PostSecurityForgotPasswordErrors, PostSecurityForgotPasswordResetData, PostSecurityForgotPasswordResetErrors, PostSecurityForgotPasswordResetResponses, PostSecurityForgotPasswordResponses, PostSecurityForgotPasswordVerifyData, PostSecurityForgotPasswordVerifyErrors, PostSecurityForgotPasswordVerifyResponses, PostStylesheetData, PostStylesheetErrors, PostStylesheetFolderData, PostStylesheetFolderErrors, PostStylesheetFolderResponses, PostStylesheetResponses, PostTelemetryLevelData, PostTelemetryLevelErrors, PostTelemetryLevelResponses, PostTemplateData, PostTemplateErrors, PostTemplateQueryExecuteData, PostTemplateQueryExecuteErrors, PostTemplateQueryExecuteResponses, PostTemplateResponses, PostTemporaryFileData, PostTemporaryFileErrors, PostTemporaryFileResponses, PostUpgradeAuthorizeData, PostUpgradeAuthorizeErrors, PostUpgradeAuthorizeResponses, PostUserAvatarByIdData, PostUserAvatarByIdErrors, PostUserAvatarByIdResponses, PostUserByIdChangePasswordData, PostUserByIdChangePasswordErrors, PostUserByIdChangePasswordResponses, PostUserByIdClientCredentialsData, PostUserByIdClientCredentialsErrors, PostUserByIdClientCredentialsResponses, PostUserByIdResetPasswordData, PostUserByIdResetPasswordErrors, PostUserByIdResetPasswordResponses, PostUserCurrent2FaByProviderNameData, PostUserCurrent2FaByProviderNameErrors, PostUserCurrent2FaByProviderNameResponses, PostUserCurrentAvatarData, PostUserCurrentAvatarErrors, PostUserCurrentAvatarResponses, PostUserCurrentChangePasswordData, PostUserCurrentChangePasswordErrors, PostUserCurrentChangePasswordResponses, PostUserData, PostUserDataData, PostUserDataErrors, PostUserDataResponses, PostUserDisableData, PostUserDisableErrors, PostUserDisableResponses, PostUserEnableData, PostUserEnableErrors, PostUserEnableResponses, PostUserErrors, PostUserGroupByIdUsersData, PostUserGroupByIdUsersErrors, PostUserGroupByIdUsersResponses, PostUserGroupData, PostUserGroupErrors, PostUserGroupResponses, PostUserInviteCreatePasswordData, PostUserInviteCreatePasswordErrors, PostUserInviteCreatePasswordResponses, PostUserInviteData, PostUserInviteErrors, PostUserInviteResendData, PostUserInviteResendErrors, PostUserInviteResendResponses, PostUserInviteResponses, PostUserInviteVerifyData, PostUserInviteVerifyErrors, PostUserInviteVerifyResponses, PostUserResponses, PostUserSetUserGroupsData, PostUserSetUserGroupsErrors, PostUserSetUserGroupsResponses, PostUserUnlockData, PostUserUnlockErrors, PostUserUnlockResponses, PostWebhookData, PostWebhookErrors, PostWebhookResponses, PutDataTypeByIdData, PutDataTypeByIdErrors, PutDataTypeByIdMoveData, PutDataTypeByIdMoveErrors, PutDataTypeByIdMoveResponses, PutDataTypeByIdResponses, PutDataTypeFolderByIdData, PutDataTypeFolderByIdErrors, PutDataTypeFolderByIdResponses, PutDictionaryByIdData, PutDictionaryByIdErrors, PutDictionaryByIdMoveData, PutDictionaryByIdMoveErrors, PutDictionaryByIdMoveResponses, PutDictionaryByIdResponses, PutDocumentBlueprintByIdData, PutDocumentBlueprintByIdErrors, PutDocumentBlueprintByIdMoveData, PutDocumentBlueprintByIdMoveErrors, PutDocumentBlueprintByIdMoveResponses, PutDocumentBlueprintByIdResponses, PutDocumentBlueprintFolderByIdData, PutDocumentBlueprintFolderByIdErrors, PutDocumentBlueprintFolderByIdResponses, PutDocumentByIdData, PutDocumentByIdDomainsData, PutDocumentByIdDomainsErrors, PutDocumentByIdDomainsResponses, PutDocumentByIdErrors, PutDocumentByIdMoveData, PutDocumentByIdMoveErrors, PutDocumentByIdMoveResponses, PutDocumentByIdMoveToRecycleBinData, PutDocumentByIdMoveToRecycleBinErrors, PutDocumentByIdMoveToRecycleBinResponses, PutDocumentByIdNotificationsData, PutDocumentByIdNotificationsErrors, PutDocumentByIdNotificationsResponses, PutDocumentByIdPublicAccessData, PutDocumentByIdPublicAccessErrors, PutDocumentByIdPublicAccessResponses, PutDocumentByIdPublishData, PutDocumentByIdPublishErrors, PutDocumentByIdPublishResponses, PutDocumentByIdPublishWithDescendantsData, PutDocumentByIdPublishWithDescendantsErrors, PutDocumentByIdPublishWithDescendantsResponses, PutDocumentByIdResponses, PutDocumentByIdUnpublishData, PutDocumentByIdUnpublishErrors, PutDocumentByIdUnpublishResponses, PutDocumentSortData, PutDocumentSortErrors, PutDocumentSortResponses, PutDocumentTypeByIdData, PutDocumentTypeByIdErrors, PutDocumentTypeByIdImportData, PutDocumentTypeByIdImportErrors, PutDocumentTypeByIdImportResponses, PutDocumentTypeByIdMoveData, PutDocumentTypeByIdMoveErrors, PutDocumentTypeByIdMoveResponses, PutDocumentTypeByIdResponses, PutDocumentTypeFolderByIdData, PutDocumentTypeFolderByIdErrors, PutDocumentTypeFolderByIdResponses, PutDocumentVersionByIdPreventCleanupData, PutDocumentVersionByIdPreventCleanupErrors, PutDocumentVersionByIdPreventCleanupResponses, PutElementByIdData, PutElementByIdErrors, PutElementByIdMoveData, PutElementByIdMoveErrors, PutElementByIdMoveResponses, PutElementByIdMoveToRecycleBinData, PutElementByIdMoveToRecycleBinErrors, PutElementByIdMoveToRecycleBinResponses, PutElementByIdPublishData, PutElementByIdPublishErrors, PutElementByIdPublishResponses, PutElementByIdResponses, PutElementByIdUnpublishData, PutElementByIdUnpublishErrors, PutElementByIdUnpublishResponses, PutElementByIdValidateData, PutElementByIdValidateErrors, PutElementByIdValidateResponses, PutElementFolderByIdData, PutElementFolderByIdErrors, PutElementFolderByIdMoveData, PutElementFolderByIdMoveErrors, PutElementFolderByIdMoveResponses, PutElementFolderByIdMoveToRecycleBinData, PutElementFolderByIdMoveToRecycleBinErrors, PutElementFolderByIdMoveToRecycleBinResponses, PutElementFolderByIdResponses, PutElementVersionByIdPreventCleanupData, PutElementVersionByIdPreventCleanupErrors, PutElementVersionByIdPreventCleanupResponses, PutLanguageByIsoCodeData, PutLanguageByIsoCodeErrors, PutLanguageByIsoCodeResponses, PutMediaByIdData, PutMediaByIdErrors, PutMediaByIdMoveData, PutMediaByIdMoveErrors, PutMediaByIdMoveResponses, PutMediaByIdMoveToRecycleBinData, PutMediaByIdMoveToRecycleBinErrors, PutMediaByIdMoveToRecycleBinResponses, PutMediaByIdResponses, PutMediaByIdValidateData, PutMediaByIdValidateErrors, PutMediaByIdValidateResponses, PutMediaSortData, PutMediaSortErrors, PutMediaSortResponses, PutMediaTypeByIdData, PutMediaTypeByIdErrors, PutMediaTypeByIdImportData, PutMediaTypeByIdImportErrors, PutMediaTypeByIdImportResponses, PutMediaTypeByIdMoveData, PutMediaTypeByIdMoveErrors, PutMediaTypeByIdMoveResponses, PutMediaTypeByIdResponses, PutMediaTypeFolderByIdData, PutMediaTypeFolderByIdErrors, PutMediaTypeFolderByIdResponses, PutMemberByIdData, PutMemberByIdErrors, PutMemberByIdResponses, PutMemberByIdValidateData, PutMemberByIdValidateErrors, PutMemberByIdValidateResponses, PutMemberGroupByIdData, PutMemberGroupByIdErrors, PutMemberGroupByIdResponses, PutMemberTypeByIdData, PutMemberTypeByIdErrors, PutMemberTypeByIdImportData, PutMemberTypeByIdImportErrors, PutMemberTypeByIdImportResponses, PutMemberTypeByIdMoveData, PutMemberTypeByIdMoveErrors, PutMemberTypeByIdMoveResponses, PutMemberTypeByIdResponses, PutMemberTypeFolderByIdData, PutMemberTypeFolderByIdErrors, PutMemberTypeFolderByIdResponses, PutPackageCreatedByIdData, PutPackageCreatedByIdErrors, PutPackageCreatedByIdResponses, PutPartialViewByPathData, PutPartialViewByPathErrors, PutPartialViewByPathRenameData, PutPartialViewByPathRenameErrors, PutPartialViewByPathRenameResponses, PutPartialViewByPathResponses, PutProfilingStatusData, PutProfilingStatusErrors, PutProfilingStatusResponses, PutRecycleBinDocumentByIdRestoreData, PutRecycleBinDocumentByIdRestoreErrors, PutRecycleBinDocumentByIdRestoreResponses, PutRecycleBinElementByIdRestoreData, PutRecycleBinElementByIdRestoreErrors, PutRecycleBinElementByIdRestoreResponses, PutRecycleBinElementFolderByIdRestoreData, PutRecycleBinElementFolderByIdRestoreErrors, PutRecycleBinElementFolderByIdRestoreResponses, PutRecycleBinMediaByIdRestoreData, PutRecycleBinMediaByIdRestoreErrors, PutRecycleBinMediaByIdRestoreResponses, PutScriptByPathData, PutScriptByPathErrors, PutScriptByPathRenameData, PutScriptByPathRenameErrors, PutScriptByPathRenameResponses, PutScriptByPathResponses, PutStylesheetByPathData, PutStylesheetByPathErrors, PutStylesheetByPathRenameData, PutStylesheetByPathRenameErrors, PutStylesheetByPathRenameResponses, PutStylesheetByPathResponses, PutTemplateByIdData, PutTemplateByIdErrors, PutTemplateByIdResponses, PutUmbracoManagementApiV11DocumentByIdValidate11Data, PutUmbracoManagementApiV11DocumentByIdValidate11Errors, PutUmbracoManagementApiV11DocumentByIdValidate11Responses, PutUserByIdData, PutUserByIdErrors, PutUserByIdResponses, PutUserDataData, PutUserDataErrors, PutUserDataResponses, PutUserGroupByIdData, PutUserGroupByIdErrors, PutUserGroupByIdResponses, PutWebhookByIdData, PutWebhookByIdErrors, PutWebhookByIdResponses } from './types.gen';
+import type { DeleteDataTypeByIdData, DeleteDataTypeByIdErrors, DeleteDataTypeByIdResponses, DeleteDataTypeFolderByIdData, DeleteDataTypeFolderByIdErrors, DeleteDataTypeFolderByIdResponses, DeleteDictionaryByIdData, DeleteDictionaryByIdErrors, DeleteDictionaryByIdResponses, DeleteDocumentBlueprintByIdData, DeleteDocumentBlueprintByIdErrors, DeleteDocumentBlueprintByIdResponses, DeleteDocumentBlueprintFolderByIdData, DeleteDocumentBlueprintFolderByIdErrors, DeleteDocumentBlueprintFolderByIdResponses, DeleteDocumentByIdData, DeleteDocumentByIdErrors, DeleteDocumentByIdPublicAccessData, DeleteDocumentByIdPublicAccessErrors, DeleteDocumentByIdPublicAccessResponses, DeleteDocumentByIdResponses, DeleteDocumentTypeByIdData, DeleteDocumentTypeByIdErrors, DeleteDocumentTypeByIdResponses, DeleteDocumentTypeFolderByIdData, DeleteDocumentTypeFolderByIdErrors, DeleteDocumentTypeFolderByIdResponses, DeleteElementByIdData, DeleteElementByIdErrors, DeleteElementByIdResponses, DeleteElementFolderByIdData, DeleteElementFolderByIdErrors, DeleteElementFolderByIdResponses, DeleteLanguageByIsoCodeData, DeleteLanguageByIsoCodeErrors, DeleteLanguageByIsoCodeResponses, DeleteLogViewerSavedSearchByNameData, DeleteLogViewerSavedSearchByNameErrors, DeleteLogViewerSavedSearchByNameResponses, DeleteMediaByIdData, DeleteMediaByIdErrors, DeleteMediaByIdResponses, DeleteMediaTypeByIdData, DeleteMediaTypeByIdErrors, DeleteMediaTypeByIdResponses, DeleteMediaTypeFolderByIdData, DeleteMediaTypeFolderByIdErrors, DeleteMediaTypeFolderByIdResponses, DeleteMemberByIdData, DeleteMemberByIdErrors, DeleteMemberByIdResponses, DeleteMemberGroupByIdData, DeleteMemberGroupByIdErrors, DeleteMemberGroupByIdResponses, DeleteMemberTypeByIdData, DeleteMemberTypeByIdErrors, DeleteMemberTypeByIdResponses, DeleteMemberTypeFolderByIdData, DeleteMemberTypeFolderByIdErrors, DeleteMemberTypeFolderByIdResponses, DeletePackageCreatedByIdData, DeletePackageCreatedByIdErrors, DeletePackageCreatedByIdResponses, DeletePartialViewByPathData, DeletePartialViewByPathErrors, DeletePartialViewByPathResponses, DeletePartialViewFolderByPathData, DeletePartialViewFolderByPathErrors, DeletePartialViewFolderByPathResponses, DeletePreviewData, DeletePreviewResponses, DeleteRecycleBinDocumentByIdData, DeleteRecycleBinDocumentByIdErrors, DeleteRecycleBinDocumentByIdResponses, DeleteRecycleBinDocumentData, DeleteRecycleBinDocumentErrors, DeleteRecycleBinDocumentResponses, DeleteRecycleBinElementByIdData, DeleteRecycleBinElementByIdErrors, DeleteRecycleBinElementByIdResponses, DeleteRecycleBinElementData, DeleteRecycleBinElementErrors, DeleteRecycleBinElementFolderByIdData, DeleteRecycleBinElementFolderByIdErrors, DeleteRecycleBinElementFolderByIdResponses, DeleteRecycleBinElementResponses, DeleteRecycleBinMediaByIdData, DeleteRecycleBinMediaByIdErrors, DeleteRecycleBinMediaByIdResponses, DeleteRecycleBinMediaData, DeleteRecycleBinMediaErrors, DeleteRecycleBinMediaResponses, DeleteRedirectManagementByIdData, DeleteRedirectManagementByIdErrors, DeleteRedirectManagementByIdResponses, DeleteScriptByPathData, DeleteScriptByPathErrors, DeleteScriptByPathResponses, DeleteScriptFolderByPathData, DeleteScriptFolderByPathErrors, DeleteScriptFolderByPathResponses, DeleteStylesheetByPathData, DeleteStylesheetByPathErrors, DeleteStylesheetByPathResponses, DeleteStylesheetFolderByPathData, DeleteStylesheetFolderByPathErrors, DeleteStylesheetFolderByPathResponses, DeleteTemplateByIdData, DeleteTemplateByIdErrors, DeleteTemplateByIdResponses, DeleteTemporaryFileByIdData, DeleteTemporaryFileByIdErrors, DeleteTemporaryFileByIdResponses, DeleteUserAvatarByIdData, DeleteUserAvatarByIdErrors, DeleteUserAvatarByIdResponses, DeleteUserById2FaByProviderNameData, DeleteUserById2FaByProviderNameErrors, DeleteUserById2FaByProviderNameResponses, DeleteUserByIdClientCredentialsByClientIdData, DeleteUserByIdClientCredentialsByClientIdErrors, DeleteUserByIdClientCredentialsByClientIdResponses, DeleteUserByIdData, DeleteUserByIdErrors, DeleteUserByIdResponses, DeleteUserCurrent2FaByProviderNameData, DeleteUserCurrent2FaByProviderNameErrors, DeleteUserCurrent2FaByProviderNameResponses, DeleteUserData, DeleteUserDataByIdData, DeleteUserDataByIdErrors, DeleteUserDataByIdResponses, DeleteUserErrors, DeleteUserGroupByIdData, DeleteUserGroupByIdErrors, DeleteUserGroupByIdResponses, DeleteUserGroupByIdUsersData, DeleteUserGroupByIdUsersErrors, DeleteUserGroupByIdUsersResponses, DeleteUserGroupData, DeleteUserGroupErrors, DeleteUserGroupResponses, DeleteUserResponses, DeleteWebhookByIdData, DeleteWebhookByIdErrors, DeleteWebhookByIdResponses, GetCollectionDocumentByIdData, GetCollectionDocumentByIdErrors, GetCollectionDocumentByIdResponses, GetCollectionMediaData, GetCollectionMediaErrors, GetCollectionMediaResponses, GetCultureData, GetCultureErrors, GetCultureResponses, GetDataTypeBatchData, GetDataTypeBatchErrors, GetDataTypeBatchResponses, GetDataTypeByIdData, GetDataTypeByIdErrors, GetDataTypeByIdIsUsedData, GetDataTypeByIdIsUsedErrors, GetDataTypeByIdIsUsedResponses, GetDataTypeByIdReferencedByData, GetDataTypeByIdReferencedByErrors, GetDataTypeByIdReferencedByResponses, GetDataTypeByIdResponses, GetDataTypeByIdSchemaData, GetDataTypeByIdSchemaErrors, GetDataTypeByIdSchemaResponses, GetDataTypeConfigurationData, GetDataTypeConfigurationErrors, GetDataTypeConfigurationResponses, GetDataTypeFolderByIdData, GetDataTypeFolderByIdErrors, GetDataTypeFolderByIdResponses, GetDataTypeSchemasBatchData, GetDataTypeSchemasBatchErrors, GetDataTypeSchemasBatchResponses, GetDictionaryByIdData, GetDictionaryByIdErrors, GetDictionaryByIdExportData, GetDictionaryByIdExportErrors, GetDictionaryByIdExportResponses, GetDictionaryByIdResponses, GetDictionaryData, GetDictionaryErrors, GetDictionaryResponses, GetDocumentAreReferencedData, GetDocumentAreReferencedErrors, GetDocumentAreReferencedResponses, GetDocumentBlueprintByIdAuditLogData, GetDocumentBlueprintByIdAuditLogErrors, GetDocumentBlueprintByIdAuditLogResponses, GetDocumentBlueprintByIdData, GetDocumentBlueprintByIdErrors, GetDocumentBlueprintByIdResponses, GetDocumentBlueprintByIdScaffoldData, GetDocumentBlueprintByIdScaffoldErrors, GetDocumentBlueprintByIdScaffoldResponses, GetDocumentBlueprintFolderByIdData, GetDocumentBlueprintFolderByIdErrors, GetDocumentBlueprintFolderByIdResponses, GetDocumentByIdAuditLogData, GetDocumentByIdAuditLogErrors, GetDocumentByIdAuditLogResponses, GetDocumentByIdAvailableSegmentOptionsData, GetDocumentByIdAvailableSegmentOptionsErrors, GetDocumentByIdAvailableSegmentOptionsResponses, GetDocumentByIdData, GetDocumentByIdDomainsData, GetDocumentByIdDomainsErrors, GetDocumentByIdDomainsResponses, GetDocumentByIdErrors, GetDocumentByIdNotificationsData, GetDocumentByIdNotificationsErrors, GetDocumentByIdNotificationsResponses, GetDocumentByIdPreviewUrlData, GetDocumentByIdPreviewUrlErrors, GetDocumentByIdPreviewUrlResponses, GetDocumentByIdPublicAccessData, GetDocumentByIdPublicAccessErrors, GetDocumentByIdPublicAccessResponses, GetDocumentByIdPublishedData, GetDocumentByIdPublishedErrors, GetDocumentByIdPublishedResponses, GetDocumentByIdPublishWithDescendantsResultByTaskIdData, GetDocumentByIdPublishWithDescendantsResultByTaskIdErrors, GetDocumentByIdPublishWithDescendantsResultByTaskIdResponses, GetDocumentByIdReferencedByData, GetDocumentByIdReferencedByErrors, GetDocumentByIdReferencedByResponses, GetDocumentByIdReferencedDescendantsData, GetDocumentByIdReferencedDescendantsErrors, GetDocumentByIdReferencedDescendantsResponses, GetDocumentByIdResponses, GetDocumentConfigurationData, GetDocumentConfigurationErrors, GetDocumentConfigurationResponses, GetDocumentTypeAllowedAtRootData, GetDocumentTypeAllowedAtRootErrors, GetDocumentTypeAllowedAtRootResponses, GetDocumentTypeAllowedInLibraryData, GetDocumentTypeAllowedInLibraryErrors, GetDocumentTypeAllowedInLibraryResponses, GetDocumentTypeBatchData, GetDocumentTypeBatchErrors, GetDocumentTypeBatchResponses, GetDocumentTypeByIdAllowedChildrenData, GetDocumentTypeByIdAllowedChildrenErrors, GetDocumentTypeByIdAllowedChildrenResponses, GetDocumentTypeByIdAllowedParentsData, GetDocumentTypeByIdAllowedParentsErrors, GetDocumentTypeByIdAllowedParentsResponses, GetDocumentTypeByIdBlueprintData, GetDocumentTypeByIdBlueprintErrors, GetDocumentTypeByIdBlueprintResponses, GetDocumentTypeByIdCompositionReferencesData, GetDocumentTypeByIdCompositionReferencesErrors, GetDocumentTypeByIdCompositionReferencesResponses, GetDocumentTypeByIdData, GetDocumentTypeByIdErrors, GetDocumentTypeByIdExportData, GetDocumentTypeByIdExportErrors, GetDocumentTypeByIdExportResponses, GetDocumentTypeByIdResponses, GetDocumentTypeByIdSchemaData, GetDocumentTypeByIdSchemaErrors, GetDocumentTypeByIdSchemaResponses, GetDocumentTypeConfigurationData, GetDocumentTypeConfigurationErrors, GetDocumentTypeConfigurationResponses, GetDocumentTypeFolderByIdData, GetDocumentTypeFolderByIdErrors, GetDocumentTypeFolderByIdResponses, GetDocumentUrlsData, GetDocumentUrlsErrors, GetDocumentUrlsResponses, GetDocumentVersionByIdData, GetDocumentVersionByIdErrors, GetDocumentVersionByIdResponses, GetDocumentVersionData, GetDocumentVersionErrors, GetDocumentVersionResponses, GetDynamicRootStepsData, GetDynamicRootStepsErrors, GetDynamicRootStepsResponses, GetElementAreReferencedData, GetElementAreReferencedErrors, GetElementAreReferencedResponses, GetElementByIdAuditLogData, GetElementByIdAuditLogErrors, GetElementByIdAuditLogResponses, GetElementByIdData, GetElementByIdErrors, GetElementByIdReferencedByData, GetElementByIdReferencedByErrors, GetElementByIdReferencedByResponses, GetElementByIdResponses, GetElementConfigurationData, GetElementConfigurationErrors, GetElementConfigurationResponses, GetElementFolderByIdData, GetElementFolderByIdErrors, GetElementFolderByIdReferencedDescendantsData, GetElementFolderByIdReferencedDescendantsErrors, GetElementFolderByIdReferencedDescendantsResponses, GetElementFolderByIdResponses, GetElementVersionByIdData, GetElementVersionByIdErrors, GetElementVersionByIdResponses, GetElementVersionData, GetElementVersionErrors, GetElementVersionResponses, GetFilterDataTypeData, GetFilterDataTypeErrors, GetFilterDataTypeResponses, GetFilterMemberData, GetFilterMemberErrors, GetFilterMemberResponses, GetFilterUserData, GetFilterUserErrors, GetFilterUserGroupData, GetFilterUserGroupErrors, GetFilterUserGroupResponses, GetFilterUserResponses, GetHealthCheckGroupByNameData, GetHealthCheckGroupByNameErrors, GetHealthCheckGroupByNameResponses, GetHealthCheckGroupData, GetHealthCheckGroupErrors, GetHealthCheckGroupResponses, GetHelpData, GetHelpErrors, GetHelpResponses, GetImagingResizeUrlsData, GetImagingResizeUrlsErrors, GetImagingResizeUrlsResponses, GetImportAnalyzeData, GetImportAnalyzeErrors, GetImportAnalyzeResponses, GetIndexerByIndexNameData, GetIndexerByIndexNameErrors, GetIndexerByIndexNameResponses, GetIndexerData, GetIndexerErrors, GetIndexerResponses, GetInstallSettingsData, GetInstallSettingsErrors, GetInstallSettingsResponses, GetItemDataTypeAncestorsData, GetItemDataTypeAncestorsErrors, GetItemDataTypeAncestorsResponses, GetItemDataTypeData, GetItemDataTypeErrors, GetItemDataTypeResponses, GetItemDataTypeSearchData, GetItemDataTypeSearchErrors, GetItemDataTypeSearchResponses, GetItemDictionaryData, GetItemDictionaryErrors, GetItemDictionaryResponses, GetItemDocumentAncestorsData, GetItemDocumentAncestorsErrors, GetItemDocumentAncestorsResponses, GetItemDocumentBlueprintData, GetItemDocumentBlueprintErrors, GetItemDocumentBlueprintResponses, GetItemDocumentData, GetItemDocumentErrors, GetItemDocumentResponses, GetItemDocumentSearchData, GetItemDocumentSearchErrors, GetItemDocumentSearchResponses, GetItemDocumentTypeAncestorsData, GetItemDocumentTypeAncestorsErrors, GetItemDocumentTypeAncestorsResponses, GetItemDocumentTypeData, GetItemDocumentTypeErrors, GetItemDocumentTypeResponses, GetItemDocumentTypeSearchData, GetItemDocumentTypeSearchErrors, GetItemDocumentTypeSearchResponses, GetItemElementData, GetItemElementErrors, GetItemElementFolderData, GetItemElementFolderErrors, GetItemElementFolderResponses, GetItemElementResponses, GetItemLanguageData, GetItemLanguageDefaultData, GetItemLanguageDefaultErrors, GetItemLanguageDefaultResponses, GetItemLanguageErrors, GetItemLanguageResponses, GetItemMediaAncestorsData, GetItemMediaAncestorsErrors, GetItemMediaAncestorsResponses, GetItemMediaData, GetItemMediaErrors, GetItemMediaResponses, GetItemMediaSearchData, GetItemMediaSearchErrors, GetItemMediaSearchResponses, GetItemMediaTypeAllowedData, GetItemMediaTypeAllowedErrors, GetItemMediaTypeAllowedResponses, GetItemMediaTypeAncestorsData, GetItemMediaTypeAncestorsErrors, GetItemMediaTypeAncestorsResponses, GetItemMediaTypeData, GetItemMediaTypeErrors, GetItemMediaTypeFoldersData, GetItemMediaTypeFoldersErrors, GetItemMediaTypeFoldersResponses, GetItemMediaTypeResponses, GetItemMediaTypeSearchData, GetItemMediaTypeSearchErrors, GetItemMediaTypeSearchResponses, GetItemMemberAncestorsData, GetItemMemberAncestorsErrors, GetItemMemberAncestorsResponses, GetItemMemberData, GetItemMemberErrors, GetItemMemberGroupData, GetItemMemberGroupErrors, GetItemMemberGroupResponses, GetItemMemberResponses, GetItemMemberSearchData, GetItemMemberSearchErrors, GetItemMemberSearchResponses, GetItemMemberTypeAncestorsData, GetItemMemberTypeAncestorsErrors, GetItemMemberTypeAncestorsResponses, GetItemMemberTypeData, GetItemMemberTypeErrors, GetItemMemberTypeResponses, GetItemMemberTypeSearchData, GetItemMemberTypeSearchErrors, GetItemMemberTypeSearchResponses, GetItemPartialViewData, GetItemPartialViewErrors, GetItemPartialViewResponses, GetItemRelationTypeData, GetItemRelationTypeErrors, GetItemRelationTypeResponses, GetItemScriptData, GetItemScriptErrors, GetItemScriptResponses, GetItemStaticFileData, GetItemStaticFileErrors, GetItemStaticFileResponses, GetItemStylesheetData, GetItemStylesheetErrors, GetItemStylesheetResponses, GetItemTemplateAncestorsData, GetItemTemplateAncestorsErrors, GetItemTemplateAncestorsResponses, GetItemTemplateData, GetItemTemplateErrors, GetItemTemplateResponses, GetItemTemplateSearchData, GetItemTemplateSearchErrors, GetItemTemplateSearchResponses, GetItemUserData, GetItemUserErrors, GetItemUserGroupData, GetItemUserGroupErrors, GetItemUserGroupResponses, GetItemUserResponses, GetItemWebhookData, GetItemWebhookErrors, GetItemWebhookResponses, GetLanguageByIsoCodeData, GetLanguageByIsoCodeErrors, GetLanguageByIsoCodeResponses, GetLanguageData, GetLanguageErrors, GetLanguageResponses, GetLogViewerLevelCountData, GetLogViewerLevelCountErrors, GetLogViewerLevelCountResponses, GetLogViewerLevelData, GetLogViewerLevelErrors, GetLogViewerLevelResponses, GetLogViewerLogData, GetLogViewerLogErrors, GetLogViewerLogResponses, GetLogViewerMessageTemplateData, GetLogViewerMessageTemplateErrors, GetLogViewerMessageTemplateResponses, GetLogViewerSavedSearchByNameData, GetLogViewerSavedSearchByNameErrors, GetLogViewerSavedSearchByNameResponses, GetLogViewerSavedSearchData, GetLogViewerSavedSearchErrors, GetLogViewerSavedSearchResponses, GetLogViewerValidateLogsSizeData, GetLogViewerValidateLogsSizeErrors, GetLogViewerValidateLogsSizeResponses, GetManifestManifestData, GetManifestManifestErrors, GetManifestManifestPrivateData, GetManifestManifestPrivateErrors, GetManifestManifestPrivateResponses, GetManifestManifestPublicData, GetManifestManifestPublicResponses, GetManifestManifestResponses, GetMediaAreReferencedData, GetMediaAreReferencedErrors, GetMediaAreReferencedResponses, GetMediaByIdAuditLogData, GetMediaByIdAuditLogErrors, GetMediaByIdAuditLogResponses, GetMediaByIdData, GetMediaByIdErrors, GetMediaByIdReferencedByData, GetMediaByIdReferencedByErrors, GetMediaByIdReferencedByResponses, GetMediaByIdReferencedDescendantsData, GetMediaByIdReferencedDescendantsErrors, GetMediaByIdReferencedDescendantsResponses, GetMediaByIdResponses, GetMediaConfigurationData, GetMediaConfigurationErrors, GetMediaConfigurationResponses, GetMediaTypeAllowedAtRootData, GetMediaTypeAllowedAtRootErrors, GetMediaTypeAllowedAtRootResponses, GetMediaTypeBatchData, GetMediaTypeBatchErrors, GetMediaTypeBatchResponses, GetMediaTypeByIdAllowedChildrenData, GetMediaTypeByIdAllowedChildrenErrors, GetMediaTypeByIdAllowedChildrenResponses, GetMediaTypeByIdAllowedParentsData, GetMediaTypeByIdAllowedParentsErrors, GetMediaTypeByIdAllowedParentsResponses, GetMediaTypeByIdCompositionReferencesData, GetMediaTypeByIdCompositionReferencesErrors, GetMediaTypeByIdCompositionReferencesResponses, GetMediaTypeByIdData, GetMediaTypeByIdErrors, GetMediaTypeByIdExportData, GetMediaTypeByIdExportErrors, GetMediaTypeByIdExportResponses, GetMediaTypeByIdResponses, GetMediaTypeByIdSchemaData, GetMediaTypeByIdSchemaErrors, GetMediaTypeByIdSchemaResponses, GetMediaTypeConfigurationData, GetMediaTypeConfigurationErrors, GetMediaTypeConfigurationResponses, GetMediaTypeFolderByIdData, GetMediaTypeFolderByIdErrors, GetMediaTypeFolderByIdResponses, GetMediaUrlsData, GetMediaUrlsErrors, GetMediaUrlsResponses, GetMemberAreReferencedData, GetMemberAreReferencedErrors, GetMemberAreReferencedResponses, GetMemberByIdData, GetMemberByIdErrors, GetMemberByIdReferencedByData, GetMemberByIdReferencedByErrors, GetMemberByIdReferencedByResponses, GetMemberByIdReferencedDescendantsData, GetMemberByIdReferencedDescendantsErrors, GetMemberByIdReferencedDescendantsResponses, GetMemberByIdResponses, GetMemberConfigurationData, GetMemberConfigurationErrors, GetMemberConfigurationResponses, GetMemberGroupByIdData, GetMemberGroupByIdErrors, GetMemberGroupByIdResponses, GetMemberGroupData, GetMemberGroupErrors, GetMemberGroupResponses, GetMemberTypeAllowedAtRootData, GetMemberTypeAllowedAtRootErrors, GetMemberTypeAllowedAtRootResponses, GetMemberTypeBatchData, GetMemberTypeBatchErrors, GetMemberTypeBatchResponses, GetMemberTypeByIdCompositionReferencesData, GetMemberTypeByIdCompositionReferencesErrors, GetMemberTypeByIdCompositionReferencesResponses, GetMemberTypeByIdData, GetMemberTypeByIdErrors, GetMemberTypeByIdExportData, GetMemberTypeByIdExportErrors, GetMemberTypeByIdExportResponses, GetMemberTypeByIdResponses, GetMemberTypeByIdSchemaData, GetMemberTypeByIdSchemaErrors, GetMemberTypeByIdSchemaResponses, GetMemberTypeConfigurationData, GetMemberTypeConfigurationErrors, GetMemberTypeConfigurationResponses, GetMemberTypeFolderByIdData, GetMemberTypeFolderByIdErrors, GetMemberTypeFolderByIdResponses, GetModelsBuilderDashboardData, GetModelsBuilderDashboardErrors, GetModelsBuilderDashboardResponses, GetModelsBuilderStatusData, GetModelsBuilderStatusErrors, GetModelsBuilderStatusResponses, GetNewsDashboardData, GetNewsDashboardErrors, GetNewsDashboardResponses, GetObjectTypesData, GetObjectTypesErrors, GetObjectTypesResponses, GetOembedQueryData, GetOembedQueryErrors, GetOembedQueryResponses, GetPackageConfigurationData, GetPackageConfigurationErrors, GetPackageConfigurationResponses, GetPackageCreatedByIdData, GetPackageCreatedByIdDownloadData, GetPackageCreatedByIdDownloadErrors, GetPackageCreatedByIdDownloadResponses, GetPackageCreatedByIdErrors, GetPackageCreatedByIdResponses, GetPackageCreatedData, GetPackageCreatedErrors, GetPackageCreatedResponses, GetPackageMigrationStatusData, GetPackageMigrationStatusErrors, GetPackageMigrationStatusResponses, GetPartialViewByPathData, GetPartialViewByPathErrors, GetPartialViewByPathResponses, GetPartialViewFolderByPathData, GetPartialViewFolderByPathErrors, GetPartialViewFolderByPathResponses, GetPartialViewSnippetByIdData, GetPartialViewSnippetByIdErrors, GetPartialViewSnippetByIdResponses, GetPartialViewSnippetData, GetPartialViewSnippetErrors, GetPartialViewSnippetResponses, GetProfilingStatusData, GetProfilingStatusErrors, GetProfilingStatusResponses, GetPropertyTypeIsUsedData, GetPropertyTypeIsUsedErrors, GetPropertyTypeIsUsedResponses, GetPublishedCacheRebuildStatusData, GetPublishedCacheRebuildStatusErrors, GetPublishedCacheRebuildStatusResponses, GetRecycleBinDocumentByIdOriginalParentData, GetRecycleBinDocumentByIdOriginalParentErrors, GetRecycleBinDocumentByIdOriginalParentResponses, GetRecycleBinDocumentChildrenData, GetRecycleBinDocumentChildrenErrors, GetRecycleBinDocumentChildrenResponses, GetRecycleBinDocumentReferencedByData, GetRecycleBinDocumentReferencedByErrors, GetRecycleBinDocumentReferencedByResponses, GetRecycleBinDocumentRootData, GetRecycleBinDocumentRootErrors, GetRecycleBinDocumentRootResponses, GetRecycleBinDocumentSiblingsData, GetRecycleBinDocumentSiblingsErrors, GetRecycleBinDocumentSiblingsResponses, GetRecycleBinElementByIdOriginalParentData, GetRecycleBinElementByIdOriginalParentErrors, GetRecycleBinElementByIdOriginalParentResponses, GetRecycleBinElementChildrenData, GetRecycleBinElementChildrenErrors, GetRecycleBinElementChildrenResponses, GetRecycleBinElementFolderByIdOriginalParentData, GetRecycleBinElementFolderByIdOriginalParentErrors, GetRecycleBinElementFolderByIdOriginalParentResponses, GetRecycleBinElementReferencedByData, GetRecycleBinElementReferencedByErrors, GetRecycleBinElementReferencedByResponses, GetRecycleBinElementRootData, GetRecycleBinElementRootErrors, GetRecycleBinElementRootResponses, GetRecycleBinElementSiblingsData, GetRecycleBinElementSiblingsErrors, GetRecycleBinElementSiblingsResponses, GetRecycleBinMediaByIdOriginalParentData, GetRecycleBinMediaByIdOriginalParentErrors, GetRecycleBinMediaByIdOriginalParentResponses, GetRecycleBinMediaChildrenData, GetRecycleBinMediaChildrenErrors, GetRecycleBinMediaChildrenResponses, GetRecycleBinMediaReferencedByData, GetRecycleBinMediaReferencedByErrors, GetRecycleBinMediaReferencedByResponses, GetRecycleBinMediaRootData, GetRecycleBinMediaRootErrors, GetRecycleBinMediaRootResponses, GetRecycleBinMediaSiblingsData, GetRecycleBinMediaSiblingsErrors, GetRecycleBinMediaSiblingsResponses, GetRedirectManagementByIdData, GetRedirectManagementByIdErrors, GetRedirectManagementByIdResponses, GetRedirectManagementData, GetRedirectManagementErrors, GetRedirectManagementResponses, GetRedirectManagementStatusData, GetRedirectManagementStatusErrors, GetRedirectManagementStatusResponses, GetRelationByRelationTypeIdData, GetRelationByRelationTypeIdErrors, GetRelationByRelationTypeIdResponses, GetRelationTypeByIdData, GetRelationTypeByIdErrors, GetRelationTypeByIdResponses, GetRelationTypeData, GetRelationTypeErrors, GetRelationTypeResponses, GetScriptByPathData, GetScriptByPathErrors, GetScriptByPathResponses, GetScriptFolderByPathData, GetScriptFolderByPathErrors, GetScriptFolderByPathResponses, GetSearcherBySearcherNameQueryData, GetSearcherBySearcherNameQueryErrors, GetSearcherBySearcherNameQueryResponses, GetSearcherData, GetSearcherErrors, GetSearcherResponses, GetSecurityConfigurationData, GetSecurityConfigurationErrors, GetSecurityConfigurationResponses, GetSegmentData, GetSegmentErrors, GetSegmentResponses, GetServerConfigurationData, GetServerConfigurationResponses, GetServerInformationData, GetServerInformationErrors, GetServerInformationResponses, GetServerStatusData, GetServerStatusErrors, GetServerStatusResponses, GetServerTroubleshootingData, GetServerTroubleshootingErrors, GetServerTroubleshootingResponses, GetServerUpgradeCheckData, GetServerUpgradeCheckErrors, GetServerUpgradeCheckResponses, GetStylesheetByPathData, GetStylesheetByPathErrors, GetStylesheetByPathResponses, GetStylesheetFolderByPathData, GetStylesheetFolderByPathErrors, GetStylesheetFolderByPathResponses, GetTagData, GetTagErrors, GetTagResponses, GetTelemetryData, GetTelemetryErrors, GetTelemetryLevelData, GetTelemetryLevelErrors, GetTelemetryLevelResponses, GetTelemetryResponses, GetTemplateByIdData, GetTemplateByIdErrors, GetTemplateByIdResponses, GetTemplateConfigurationData, GetTemplateConfigurationErrors, GetTemplateConfigurationResponses, GetTemplateQuerySettingsData, GetTemplateQuerySettingsErrors, GetTemplateQuerySettingsResponses, GetTemporaryFileByIdData, GetTemporaryFileByIdErrors, GetTemporaryFileByIdResponses, GetTemporaryFileConfigurationData, GetTemporaryFileConfigurationErrors, GetTemporaryFileConfigurationResponses, GetTreeDataTypeAncestorsData, GetTreeDataTypeAncestorsErrors, GetTreeDataTypeAncestorsResponses, GetTreeDataTypeChildrenData, GetTreeDataTypeChildrenErrors, GetTreeDataTypeChildrenResponses, GetTreeDataTypeRootData, GetTreeDataTypeRootErrors, GetTreeDataTypeRootResponses, GetTreeDataTypeSearchData, GetTreeDataTypeSearchErrors, GetTreeDataTypeSearchResponses, GetTreeDataTypeSiblingsData, GetTreeDataTypeSiblingsErrors, GetTreeDataTypeSiblingsResponses, GetTreeDictionaryAncestorsData, GetTreeDictionaryAncestorsErrors, GetTreeDictionaryAncestorsResponses, GetTreeDictionaryChildrenData, GetTreeDictionaryChildrenErrors, GetTreeDictionaryChildrenResponses, GetTreeDictionaryRootData, GetTreeDictionaryRootErrors, GetTreeDictionaryRootResponses, GetTreeDocumentAncestorsData, GetTreeDocumentAncestorsErrors, GetTreeDocumentAncestorsResponses, GetTreeDocumentBlueprintAncestorsData, GetTreeDocumentBlueprintAncestorsErrors, GetTreeDocumentBlueprintAncestorsResponses, GetTreeDocumentBlueprintChildrenData, GetTreeDocumentBlueprintChildrenErrors, GetTreeDocumentBlueprintChildrenResponses, GetTreeDocumentBlueprintRootData, GetTreeDocumentBlueprintRootErrors, GetTreeDocumentBlueprintRootResponses, GetTreeDocumentBlueprintSiblingsData, GetTreeDocumentBlueprintSiblingsErrors, GetTreeDocumentBlueprintSiblingsResponses, GetTreeDocumentChildrenData, GetTreeDocumentChildrenErrors, GetTreeDocumentChildrenResponses, GetTreeDocumentRootData, GetTreeDocumentRootErrors, GetTreeDocumentRootResponses, GetTreeDocumentSiblingsData, GetTreeDocumentSiblingsErrors, GetTreeDocumentSiblingsResponses, GetTreeDocumentTypeAncestorsData, GetTreeDocumentTypeAncestorsErrors, GetTreeDocumentTypeAncestorsResponses, GetTreeDocumentTypeChildrenData, GetTreeDocumentTypeChildrenErrors, GetTreeDocumentTypeChildrenResponses, GetTreeDocumentTypeRootData, GetTreeDocumentTypeRootErrors, GetTreeDocumentTypeRootResponses, GetTreeDocumentTypeSearchData, GetTreeDocumentTypeSearchErrors, GetTreeDocumentTypeSearchResponses, GetTreeDocumentTypeSiblingsData, GetTreeDocumentTypeSiblingsErrors, GetTreeDocumentTypeSiblingsResponses, GetTreeElementAncestorsData, GetTreeElementAncestorsErrors, GetTreeElementAncestorsResponses, GetTreeElementChildrenData, GetTreeElementChildrenErrors, GetTreeElementChildrenResponses, GetTreeElementRootData, GetTreeElementRootErrors, GetTreeElementRootResponses, GetTreeElementSiblingsData, GetTreeElementSiblingsErrors, GetTreeElementSiblingsResponses, GetTreeMediaAncestorsData, GetTreeMediaAncestorsErrors, GetTreeMediaAncestorsResponses, GetTreeMediaChildrenData, GetTreeMediaChildrenErrors, GetTreeMediaChildrenResponses, GetTreeMediaRootData, GetTreeMediaRootErrors, GetTreeMediaRootResponses, GetTreeMediaSiblingsData, GetTreeMediaSiblingsErrors, GetTreeMediaSiblingsResponses, GetTreeMediaTypeAncestorsData, GetTreeMediaTypeAncestorsErrors, GetTreeMediaTypeAncestorsResponses, GetTreeMediaTypeChildrenData, GetTreeMediaTypeChildrenErrors, GetTreeMediaTypeChildrenResponses, GetTreeMediaTypeRootData, GetTreeMediaTypeRootErrors, GetTreeMediaTypeRootResponses, GetTreeMediaTypeSiblingsData, GetTreeMediaTypeSiblingsErrors, GetTreeMediaTypeSiblingsResponses, GetTreeMemberGroupRootData, GetTreeMemberGroupRootErrors, GetTreeMemberGroupRootResponses, GetTreeMemberTypeAncestorsData, GetTreeMemberTypeAncestorsErrors, GetTreeMemberTypeAncestorsResponses, GetTreeMemberTypeChildrenData, GetTreeMemberTypeChildrenErrors, GetTreeMemberTypeChildrenResponses, GetTreeMemberTypeRootData, GetTreeMemberTypeRootErrors, GetTreeMemberTypeRootResponses, GetTreeMemberTypeSiblingsData, GetTreeMemberTypeSiblingsErrors, GetTreeMemberTypeSiblingsResponses, GetTreePartialViewAncestorsData, GetTreePartialViewAncestorsErrors, GetTreePartialViewAncestorsResponses, GetTreePartialViewChildrenData, GetTreePartialViewChildrenErrors, GetTreePartialViewChildrenResponses, GetTreePartialViewRootData, GetTreePartialViewRootErrors, GetTreePartialViewRootResponses, GetTreePartialViewSiblingsData, GetTreePartialViewSiblingsErrors, GetTreePartialViewSiblingsResponses, GetTreeScriptAncestorsData, GetTreeScriptAncestorsErrors, GetTreeScriptAncestorsResponses, GetTreeScriptChildrenData, GetTreeScriptChildrenErrors, GetTreeScriptChildrenResponses, GetTreeScriptRootData, GetTreeScriptRootErrors, GetTreeScriptRootResponses, GetTreeScriptSiblingsData, GetTreeScriptSiblingsErrors, GetTreeScriptSiblingsResponses, GetTreeStaticFileAncestorsData, GetTreeStaticFileAncestorsErrors, GetTreeStaticFileAncestorsResponses, GetTreeStaticFileChildrenData, GetTreeStaticFileChildrenErrors, GetTreeStaticFileChildrenResponses, GetTreeStaticFileRootData, GetTreeStaticFileRootErrors, GetTreeStaticFileRootResponses, GetTreeStylesheetAncestorsData, GetTreeStylesheetAncestorsErrors, GetTreeStylesheetAncestorsResponses, GetTreeStylesheetChildrenData, GetTreeStylesheetChildrenErrors, GetTreeStylesheetChildrenResponses, GetTreeStylesheetRootData, GetTreeStylesheetRootErrors, GetTreeStylesheetRootResponses, GetTreeStylesheetSiblingsData, GetTreeStylesheetSiblingsErrors, GetTreeStylesheetSiblingsResponses, GetTreeTemplateAncestorsData, GetTreeTemplateAncestorsErrors, GetTreeTemplateAncestorsResponses, GetTreeTemplateChildrenData, GetTreeTemplateChildrenErrors, GetTreeTemplateChildrenResponses, GetTreeTemplateRootData, GetTreeTemplateRootErrors, GetTreeTemplateRootResponses, GetTreeTemplateSiblingsData, GetTreeTemplateSiblingsErrors, GetTreeTemplateSiblingsResponses, GetUpgradeSettingsData, GetUpgradeSettingsErrors, GetUpgradeSettingsResponses, GetUserById2FaData, GetUserById2FaErrors, GetUserById2FaResponses, GetUserByIdCalculateStartNodesData, GetUserByIdCalculateStartNodesErrors, GetUserByIdCalculateStartNodesResponses, GetUserByIdClientCredentialsData, GetUserByIdClientCredentialsErrors, GetUserByIdClientCredentialsResponses, GetUserByIdData, GetUserByIdErrors, GetUserByIdResponses, GetUserConfigurationData, GetUserConfigurationErrors, GetUserConfigurationResponses, GetUserCurrent2FaByProviderNameData, GetUserCurrent2FaByProviderNameErrors, GetUserCurrent2FaByProviderNameResponses, GetUserCurrent2FaData, GetUserCurrent2FaErrors, GetUserCurrent2FaResponses, GetUserCurrentConfigurationData, GetUserCurrentConfigurationErrors, GetUserCurrentConfigurationResponses, GetUserCurrentData, GetUserCurrentErrors, GetUserCurrentLoginProvidersData, GetUserCurrentLoginProvidersErrors, GetUserCurrentLoginProvidersResponses, GetUserCurrentPermissionsData, GetUserCurrentPermissionsDocumentData, GetUserCurrentPermissionsDocumentErrors, GetUserCurrentPermissionsDocumentResponses, GetUserCurrentPermissionsElementData, GetUserCurrentPermissionsElementErrors, GetUserCurrentPermissionsElementResponses, GetUserCurrentPermissionsErrors, GetUserCurrentPermissionsMediaData, GetUserCurrentPermissionsMediaErrors, GetUserCurrentPermissionsMediaResponses, GetUserCurrentPermissionsResponses, GetUserCurrentResponses, GetUserData, GetUserDataByIdData, GetUserDataByIdErrors, GetUserDataByIdResponses, GetUserDataData, GetUserDataErrors, GetUserDataResponses, GetUserErrors, GetUserGroupByIdData, GetUserGroupByIdErrors, GetUserGroupByIdResponses, GetUserGroupData, GetUserGroupErrors, GetUserGroupResponses, GetUserResponses, GetWebhookByIdData, GetWebhookByIdErrors, GetWebhookByIdLogsData, GetWebhookByIdLogsErrors, GetWebhookByIdLogsResponses, GetWebhookByIdResponses, GetWebhookData, GetWebhookErrors, GetWebhookEventsData, GetWebhookEventsErrors, GetWebhookEventsResponses, GetWebhookLogsData, GetWebhookLogsErrors, GetWebhookLogsResponses, GetWebhookResponses, PostDataTypeByIdCopyData, PostDataTypeByIdCopyErrors, PostDataTypeByIdCopyResponses, PostDataTypeData, PostDataTypeErrors, PostDataTypeFolderData, PostDataTypeFolderErrors, PostDataTypeFolderResponses, PostDataTypeResponses, PostDictionaryData, PostDictionaryErrors, PostDictionaryImportData, PostDictionaryImportErrors, PostDictionaryImportResponses, PostDictionaryResponses, PostDocumentBlueprintData, PostDocumentBlueprintErrors, PostDocumentBlueprintFolderData, PostDocumentBlueprintFolderErrors, PostDocumentBlueprintFolderResponses, PostDocumentBlueprintFromDocumentData, PostDocumentBlueprintFromDocumentErrors, PostDocumentBlueprintFromDocumentResponses, PostDocumentBlueprintResponses, PostDocumentByIdCopyData, PostDocumentByIdCopyErrors, PostDocumentByIdCopyResponses, PostDocumentByIdPublicAccessData, PostDocumentByIdPublicAccessErrors, PostDocumentByIdPublicAccessResponses, PostDocumentData, PostDocumentErrors, PostDocumentResponses, PostDocumentTypeAvailableCompositionsData, PostDocumentTypeAvailableCompositionsErrors, PostDocumentTypeAvailableCompositionsResponses, PostDocumentTypeByIdCopyData, PostDocumentTypeByIdCopyErrors, PostDocumentTypeByIdCopyResponses, PostDocumentTypeByIdTemplateData, PostDocumentTypeByIdTemplateErrors, PostDocumentTypeByIdTemplateResponses, PostDocumentTypeData, PostDocumentTypeErrors, PostDocumentTypeFolderData, PostDocumentTypeFolderErrors, PostDocumentTypeFolderResponses, PostDocumentTypeImportData, PostDocumentTypeImportErrors, PostDocumentTypeImportResponses, PostDocumentTypeResponses, PostDocumentValidateData, PostDocumentValidateErrors, PostDocumentValidateResponses, PostDocumentVersionByIdRollbackData, PostDocumentVersionByIdRollbackErrors, PostDocumentVersionByIdRollbackResponses, PostDynamicRootQueryData, PostDynamicRootQueryErrors, PostDynamicRootQueryResponses, PostElementByIdCopyData, PostElementByIdCopyErrors, PostElementByIdCopyResponses, PostElementData, PostElementErrors, PostElementFolderData, PostElementFolderErrors, PostElementFolderResponses, PostElementResponses, PostElementValidateData, PostElementValidateErrors, PostElementValidateResponses, PostElementVersionByIdRollbackData, PostElementVersionByIdRollbackErrors, PostElementVersionByIdRollbackResponses, PostHealthCheckExecuteActionData, PostHealthCheckExecuteActionErrors, PostHealthCheckExecuteActionResponses, PostHealthCheckGroupByNameCheckData, PostHealthCheckGroupByNameCheckErrors, PostHealthCheckGroupByNameCheckResponses, PostIndexerByIndexNameRebuildData, PostIndexerByIndexNameRebuildErrors, PostIndexerByIndexNameRebuildResponses, PostInstallSetupData, PostInstallSetupErrors, PostInstallSetupResponses, PostInstallValidateDatabaseData, PostInstallValidateDatabaseErrors, PostInstallValidateDatabaseResponses, PostLanguageData, PostLanguageErrors, PostLanguageResponses, PostLogViewerSavedSearchData, PostLogViewerSavedSearchErrors, PostLogViewerSavedSearchResponses, PostMediaData, PostMediaErrors, PostMediaResponses, PostMediaTypeAvailableCompositionsData, PostMediaTypeAvailableCompositionsErrors, PostMediaTypeAvailableCompositionsResponses, PostMediaTypeByIdCopyData, PostMediaTypeByIdCopyErrors, PostMediaTypeByIdCopyResponses, PostMediaTypeData, PostMediaTypeErrors, PostMediaTypeFolderData, PostMediaTypeFolderErrors, PostMediaTypeFolderResponses, PostMediaTypeImportData, PostMediaTypeImportErrors, PostMediaTypeImportResponses, PostMediaTypeResponses, PostMediaValidateData, PostMediaValidateErrors, PostMediaValidateResponses, PostMemberData, PostMemberErrors, PostMemberGroupData, PostMemberGroupErrors, PostMemberGroupResponses, PostMemberResponses, PostMemberTypeAvailableCompositionsData, PostMemberTypeAvailableCompositionsErrors, PostMemberTypeAvailableCompositionsResponses, PostMemberTypeByIdCopyData, PostMemberTypeByIdCopyErrors, PostMemberTypeByIdCopyResponses, PostMemberTypeData, PostMemberTypeErrors, PostMemberTypeFolderData, PostMemberTypeFolderErrors, PostMemberTypeFolderResponses, PostMemberTypeImportData, PostMemberTypeImportErrors, PostMemberTypeImportResponses, PostMemberTypeResponses, PostMemberValidateData, PostMemberValidateErrors, PostMemberValidateResponses, PostModelsBuilderBuildData, PostModelsBuilderBuildErrors, PostModelsBuilderBuildResponses, PostPackageByNameRunMigrationData, PostPackageByNameRunMigrationErrors, PostPackageByNameRunMigrationResponses, PostPackageCreatedData, PostPackageCreatedErrors, PostPackageCreatedResponses, PostPartialViewData, PostPartialViewErrors, PostPartialViewFolderData, PostPartialViewFolderErrors, PostPartialViewFolderResponses, PostPartialViewResponses, PostPublishedCacheRebuildData, PostPublishedCacheRebuildErrors, PostPublishedCacheRebuildResponses, PostPublishedCacheReloadData, PostPublishedCacheReloadErrors, PostPublishedCacheReloadResponses, PostRedirectManagementStatusData, PostRedirectManagementStatusErrors, PostRedirectManagementStatusResponses, PostScriptData, PostScriptErrors, PostScriptFolderData, PostScriptFolderErrors, PostScriptFolderResponses, PostScriptResponses, PostSecurityForgotPasswordData, PostSecurityForgotPasswordErrors, PostSecurityForgotPasswordResetData, PostSecurityForgotPasswordResetErrors, PostSecurityForgotPasswordResetResponses, PostSecurityForgotPasswordResponses, PostSecurityForgotPasswordVerifyData, PostSecurityForgotPasswordVerifyErrors, PostSecurityForgotPasswordVerifyResponses, PostStylesheetData, PostStylesheetErrors, PostStylesheetFolderData, PostStylesheetFolderErrors, PostStylesheetFolderResponses, PostStylesheetResponses, PostTelemetryLevelData, PostTelemetryLevelErrors, PostTelemetryLevelResponses, PostTemplateData, PostTemplateErrors, PostTemplateQueryExecuteData, PostTemplateQueryExecuteErrors, PostTemplateQueryExecuteResponses, PostTemplateResponses, PostTemporaryFileData, PostTemporaryFileErrors, PostTemporaryFileResponses, PostUpgradeAuthorizeData, PostUpgradeAuthorizeErrors, PostUpgradeAuthorizeResponses, PostUserAvatarByIdData, PostUserAvatarByIdErrors, PostUserAvatarByIdResponses, PostUserByIdChangePasswordData, PostUserByIdChangePasswordErrors, PostUserByIdChangePasswordResponses, PostUserByIdClientCredentialsData, PostUserByIdClientCredentialsErrors, PostUserByIdClientCredentialsResponses, PostUserByIdResetPasswordData, PostUserByIdResetPasswordErrors, PostUserByIdResetPasswordResponses, PostUserCurrent2FaByProviderNameData, PostUserCurrent2FaByProviderNameErrors, PostUserCurrent2FaByProviderNameResponses, PostUserCurrentAvatarData, PostUserCurrentAvatarErrors, PostUserCurrentAvatarResponses, PostUserCurrentChangePasswordData, PostUserCurrentChangePasswordErrors, PostUserCurrentChangePasswordResponses, PostUserData, PostUserDataData, PostUserDataErrors, PostUserDataResponses, PostUserDisableData, PostUserDisableErrors, PostUserDisableResponses, PostUserEnableData, PostUserEnableErrors, PostUserEnableResponses, PostUserErrors, PostUserGroupByIdUsersData, PostUserGroupByIdUsersErrors, PostUserGroupByIdUsersResponses, PostUserGroupData, PostUserGroupErrors, PostUserGroupResponses, PostUserInviteCreatePasswordData, PostUserInviteCreatePasswordErrors, PostUserInviteCreatePasswordResponses, PostUserInviteData, PostUserInviteErrors, PostUserInviteResendData, PostUserInviteResendErrors, PostUserInviteResendResponses, PostUserInviteResponses, PostUserInviteVerifyData, PostUserInviteVerifyErrors, PostUserInviteVerifyResponses, PostUserResponses, PostUserSetUserGroupsData, PostUserSetUserGroupsErrors, PostUserSetUserGroupsResponses, PostUserUnlockData, PostUserUnlockErrors, PostUserUnlockResponses, PostWebhookData, PostWebhookErrors, PostWebhookResponses, PutDataTypeByIdData, PutDataTypeByIdErrors, PutDataTypeByIdMoveData, PutDataTypeByIdMoveErrors, PutDataTypeByIdMoveResponses, PutDataTypeByIdResponses, PutDataTypeFolderByIdData, PutDataTypeFolderByIdErrors, PutDataTypeFolderByIdResponses, PutDictionaryByIdData, PutDictionaryByIdErrors, PutDictionaryByIdMoveData, PutDictionaryByIdMoveErrors, PutDictionaryByIdMoveResponses, PutDictionaryByIdResponses, PutDocumentBlueprintByIdData, PutDocumentBlueprintByIdErrors, PutDocumentBlueprintByIdMoveData, PutDocumentBlueprintByIdMoveErrors, PutDocumentBlueprintByIdMoveResponses, PutDocumentBlueprintByIdResponses, PutDocumentBlueprintFolderByIdData, PutDocumentBlueprintFolderByIdErrors, PutDocumentBlueprintFolderByIdResponses, PutDocumentByIdData, PutDocumentByIdDomainsData, PutDocumentByIdDomainsErrors, PutDocumentByIdDomainsResponses, PutDocumentByIdErrors, PutDocumentByIdMoveData, PutDocumentByIdMoveErrors, PutDocumentByIdMoveResponses, PutDocumentByIdMoveToRecycleBinData, PutDocumentByIdMoveToRecycleBinErrors, PutDocumentByIdMoveToRecycleBinResponses, PutDocumentByIdNotificationsData, PutDocumentByIdNotificationsErrors, PutDocumentByIdNotificationsResponses, PutDocumentByIdPublicAccessData, PutDocumentByIdPublicAccessErrors, PutDocumentByIdPublicAccessResponses, PutDocumentByIdPublishData, PutDocumentByIdPublishErrors, PutDocumentByIdPublishResponses, PutDocumentByIdPublishWithDescendantsData, PutDocumentByIdPublishWithDescendantsErrors, PutDocumentByIdPublishWithDescendantsResponses, PutDocumentByIdResponses, PutDocumentByIdUnpublishData, PutDocumentByIdUnpublishErrors, PutDocumentByIdUnpublishResponses, PutDocumentSortData, PutDocumentSortErrors, PutDocumentSortResponses, PutDocumentTypeByIdData, PutDocumentTypeByIdErrors, PutDocumentTypeByIdImportData, PutDocumentTypeByIdImportErrors, PutDocumentTypeByIdImportResponses, PutDocumentTypeByIdMoveData, PutDocumentTypeByIdMoveErrors, PutDocumentTypeByIdMoveResponses, PutDocumentTypeByIdResponses, PutDocumentTypeFolderByIdData, PutDocumentTypeFolderByIdErrors, PutDocumentTypeFolderByIdResponses, PutDocumentVersionByIdPreventCleanupData, PutDocumentVersionByIdPreventCleanupErrors, PutDocumentVersionByIdPreventCleanupResponses, PutElementByIdData, PutElementByIdErrors, PutElementByIdMoveData, PutElementByIdMoveErrors, PutElementByIdMoveResponses, PutElementByIdMoveToRecycleBinData, PutElementByIdMoveToRecycleBinErrors, PutElementByIdMoveToRecycleBinResponses, PutElementByIdPublishData, PutElementByIdPublishErrors, PutElementByIdPublishResponses, PutElementByIdResponses, PutElementByIdUnpublishData, PutElementByIdUnpublishErrors, PutElementByIdUnpublishResponses, PutElementByIdValidateData, PutElementByIdValidateErrors, PutElementByIdValidateResponses, PutElementFolderByIdData, PutElementFolderByIdErrors, PutElementFolderByIdMoveData, PutElementFolderByIdMoveErrors, PutElementFolderByIdMoveResponses, PutElementFolderByIdMoveToRecycleBinData, PutElementFolderByIdMoveToRecycleBinErrors, PutElementFolderByIdMoveToRecycleBinResponses, PutElementFolderByIdResponses, PutElementVersionByIdPreventCleanupData, PutElementVersionByIdPreventCleanupErrors, PutElementVersionByIdPreventCleanupResponses, PutLanguageByIsoCodeData, PutLanguageByIsoCodeErrors, PutLanguageByIsoCodeResponses, PutMediaByIdData, PutMediaByIdErrors, PutMediaByIdMoveData, PutMediaByIdMoveErrors, PutMediaByIdMoveResponses, PutMediaByIdMoveToRecycleBinData, PutMediaByIdMoveToRecycleBinErrors, PutMediaByIdMoveToRecycleBinResponses, PutMediaByIdResponses, PutMediaByIdValidateData, PutMediaByIdValidateErrors, PutMediaByIdValidateResponses, PutMediaSortData, PutMediaSortErrors, PutMediaSortResponses, PutMediaTypeByIdData, PutMediaTypeByIdErrors, PutMediaTypeByIdImportData, PutMediaTypeByIdImportErrors, PutMediaTypeByIdImportResponses, PutMediaTypeByIdMoveData, PutMediaTypeByIdMoveErrors, PutMediaTypeByIdMoveResponses, PutMediaTypeByIdResponses, PutMediaTypeFolderByIdData, PutMediaTypeFolderByIdErrors, PutMediaTypeFolderByIdResponses, PutMemberByIdData, PutMemberByIdErrors, PutMemberByIdResponses, PutMemberByIdValidateData, PutMemberByIdValidateErrors, PutMemberByIdValidateResponses, PutMemberGroupByIdData, PutMemberGroupByIdErrors, PutMemberGroupByIdResponses, PutMemberTypeByIdData, PutMemberTypeByIdErrors, PutMemberTypeByIdImportData, PutMemberTypeByIdImportErrors, PutMemberTypeByIdImportResponses, PutMemberTypeByIdMoveData, PutMemberTypeByIdMoveErrors, PutMemberTypeByIdMoveResponses, PutMemberTypeByIdResponses, PutMemberTypeFolderByIdData, PutMemberTypeFolderByIdErrors, PutMemberTypeFolderByIdResponses, PutPackageCreatedByIdData, PutPackageCreatedByIdErrors, PutPackageCreatedByIdResponses, PutPartialViewByPathData, PutPartialViewByPathErrors, PutPartialViewByPathRenameData, PutPartialViewByPathRenameErrors, PutPartialViewByPathRenameResponses, PutPartialViewByPathResponses, PutProfilingStatusData, PutProfilingStatusErrors, PutProfilingStatusResponses, PutRecycleBinDocumentByIdRestoreData, PutRecycleBinDocumentByIdRestoreErrors, PutRecycleBinDocumentByIdRestoreResponses, PutRecycleBinElementByIdRestoreData, PutRecycleBinElementByIdRestoreErrors, PutRecycleBinElementByIdRestoreResponses, PutRecycleBinElementFolderByIdRestoreData, PutRecycleBinElementFolderByIdRestoreErrors, PutRecycleBinElementFolderByIdRestoreResponses, PutRecycleBinMediaByIdRestoreData, PutRecycleBinMediaByIdRestoreErrors, PutRecycleBinMediaByIdRestoreResponses, PutScriptByPathData, PutScriptByPathErrors, PutScriptByPathRenameData, PutScriptByPathRenameErrors, PutScriptByPathRenameResponses, PutScriptByPathResponses, PutStylesheetByPathData, PutStylesheetByPathErrors, PutStylesheetByPathRenameData, PutStylesheetByPathRenameErrors, PutStylesheetByPathRenameResponses, PutStylesheetByPathResponses, PutTemplateByIdData, PutTemplateByIdErrors, PutTemplateByIdResponses, PutUmbracoManagementApiV11DocumentByIdValidate11Data, PutUmbracoManagementApiV11DocumentByIdValidate11Errors, PutUmbracoManagementApiV11DocumentByIdValidate11Responses, PutUserByIdData, PutUserByIdErrors, PutUserByIdResponses, PutUserDataData, PutUserDataErrors, PutUserDataResponses, PutUserGroupByIdData, PutUserGroupByIdErrors, PutUserGroupByIdResponses, PutWebhookByIdData, PutWebhookByIdErrors, PutWebhookByIdResponses } from './types.gen';
 
 export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean> = Options2<TData, ThrowOnError> & {
     /**
@@ -775,6 +775,23 @@ export class DocumentBlueprintService {
         });
     }
     
+    /**
+     * Gets the audit log for a document blueprint.
+     * Gets a paginated collection of audit log entries for the document blueprint identified by the provided Id.
+     */
+    public static getDocumentBlueprintByIdAuditLog<ThrowOnError extends boolean = true>(options: Options<GetDocumentBlueprintByIdAuditLogData, ThrowOnError>) {
+        return (options.client ?? client).get<GetDocumentBlueprintByIdAuditLogResponses, GetDocumentBlueprintByIdAuditLogErrors, ThrowOnError>({
+            security: [
+                {
+                    scheme: 'bearer',
+                    type: 'http'
+                }
+            ],
+            url: '/umbraco/management/api/v1/document-blueprint/{id}/audit-log',
+            ...options
+        });
+    }
+    
     /**
      * Moves a document blueprint.
      * Moves a document blueprint identified by the provided Id to a different location.
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/backend-api/types.gen.ts b/src/Umbraco.Web.UI.Client/src/packages/core/backend-api/types.gen.ts
index bc2c250468db..0be11cb42731 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/backend-api/types.gen.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/backend-api/types.gen.ts
@@ -985,12 +985,12 @@ export type DocumentVariantResponseModel = {
     name: string;
     createDate: string;
     updateDate: string;
+    readonly id: string;
+    flags: Array<FlagModel>;
     state: DocumentVariantStateModel;
     publishDate?: string | null;
     scheduledPublishDate?: string | null;
     scheduledUnpublishDate?: string | null;
-    readonly id: string;
-    flags: Array<FlagModel>;
 };
 
 export enum DocumentVariantStateModel {
@@ -1153,6 +1153,8 @@ export type ElementValueResponseModel = {
 export type ElementVariantItemResponseModel = {
     name: string;
     culture?: string | null;
+    readonly id: string;
+    flags: Array<FlagModel>;
     state: DocumentVariantStateModel;
 };
 
@@ -1168,6 +1170,8 @@ export type ElementVariantResponseModel = {
     name: string;
     createDate: string;
     updateDate: string;
+    readonly id: string;
+    flags: Array<FlagModel>;
     state: DocumentVariantStateModel;
     publishDate?: string | null;
     scheduledPublishDate?: string | null;
@@ -1355,6 +1359,7 @@ export type IndexResponseModel = {
     providerProperties?: {
         [key: string]: unknown;
     } | null;
+    uniqueKeyFieldName?: string | null;
 };
 
 export type InstallRequestModel = {
@@ -3476,11 +3481,31 @@ export type DocumentVariantResponseModelWritable = {
     name: string;
     createDate: string;
     updateDate: string;
+    flags: Array<FlagModel>;
     state: DocumentVariantStateModel;
     publishDate?: string | null;
     scheduledPublishDate?: string | null;
     scheduledUnpublishDate?: string | null;
+};
+
+export type ElementVariantItemResponseModelWritable = {
+    name: string;
+    culture?: string | null;
     flags: Array<FlagModel>;
+    state: DocumentVariantStateModel;
+};
+
+export type ElementVariantResponseModelWritable = {
+    culture?: string | null;
+    segment?: string | null;
+    name: string;
+    createDate: string;
+    updateDate: string;
+    flags: Array<FlagModel>;
+    state: DocumentVariantStateModel;
+    publishDate?: string | null;
+    scheduledPublishDate?: string | null;
+    scheduledUnpublishDate?: string | null;
 };
 
 export type JsonNodeWritable = {
@@ -4920,6 +4945,40 @@ export type PutDocumentBlueprintByIdResponses = {
     200: unknown;
 };
 
+export type GetDocumentBlueprintByIdAuditLogData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        orderDirection?: DirectionModel;
+        sinceDate?: string;
+        skip?: number;
+        take?: number;
+    };
+    url: '/umbraco/management/api/v1/document-blueprint/{id}/audit-log';
+};
+
+export type GetDocumentBlueprintByIdAuditLogErrors = {
+    /**
+     * The resource is protected and requires an authentication token
+     */
+    401: unknown;
+    /**
+     * The authenticated user does not have access to this resource
+     */
+    403: unknown;
+};
+
+export type GetDocumentBlueprintByIdAuditLogResponses = {
+    /**
+     * OK
+     */
+    200: PagedAuditLogResponseModel;
+};
+
+export type GetDocumentBlueprintByIdAuditLogResponse = GetDocumentBlueprintByIdAuditLogResponses[keyof GetDocumentBlueprintByIdAuditLogResponses];
+
 export type PutDocumentBlueprintByIdMoveData = {
     body?: MoveDocumentBlueprintRequestModel;
     path: {
@@ -9613,6 +9672,7 @@ export type GetTreeElementChildrenData = {
         skip?: number;
         take?: number;
         foldersOnly?: boolean;
+        dataTypeId?: string;
     };
     url: '/umbraco/management/api/v1/tree/element/children';
 };
@@ -9644,6 +9704,7 @@ export type GetTreeElementRootData = {
         skip?: number;
         take?: number;
         foldersOnly?: boolean;
+        dataTypeId?: string;
     };
     url: '/umbraco/management/api/v1/tree/element/root';
 };
@@ -9676,6 +9737,7 @@ export type GetTreeElementSiblingsData = {
         before?: number;
         after?: number;
         foldersOnly?: boolean;
+        dataTypeId?: string;
     };
     url: '/umbraco/management/api/v1/tree/element/siblings';
 };
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/components/history/history-item.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/components/history/history-item.element.ts
index a5814884c343..f7105579195c 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/components/history/history-item.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/components/history/history-item.element.ts
@@ -56,7 +56,6 @@ export class UmbHistoryItemElement extends UmbLitElement {
 			.user-info {
 				position: relative;
 				display: flex;
-				align-items: flex-end;
 				gap: var(--uui-size-space-5);
 			}
 
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/components/index.ts b/src/Umbraco.Web.UI.Client/src/packages/core/components/index.ts
index a5cc1603ae6f..0361a3c8ff3f 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/components/index.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/components/index.ts
@@ -14,6 +14,7 @@ export * from './history/index.js';
 export * from './icon/index.js';
 export * from './input-color/index.js';
 export * from './input-date/index.js';
+export * from './input-dimensions/index.js';
 export * from './input-dropdown/index.js';
 export * from './input-entity/index.js';
 export * from './input-eye-dropper/index.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dimensions/index.ts b/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dimensions/index.ts
new file mode 100644
index 000000000000..d67460fa6ac8
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dimensions/index.ts
@@ -0,0 +1 @@
+export * from './input-dimensions.element.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dimensions/input-dimensions.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dimensions/input-dimensions.element.ts
new file mode 100644
index 000000000000..603ffe6d9fdb
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dimensions/input-dimensions.element.ts
@@ -0,0 +1,221 @@
+import { css, customElement, html, nothing, property } from '@umbraco-cms/backoffice/external/lit';
+import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
+import { UmbFormControlMixin } from '@umbraco-cms/backoffice/validation';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import type { UUIInputEvent } from '@umbraco-cms/backoffice/external/uui';
+
+export interface UmbInputDimensionsValue {
+	width?: number;
+	height?: number;
+}
+
+/**
+ * A dimension input element with width/height fields and an aspect ratio lock.
+ * @element umb-input-dimensions
+ * @fires UmbChangeEvent - When width, height, or locked state changes.
+ */
+@customElement('umb-input-dimensions')
+export class UmbInputDimensionsElement extends UmbFormControlMixin<
+	UmbInputDimensionsValue | undefined,
+	typeof UmbLitElement
+>(UmbLitElement, undefined) {
+	#ratio?: number;
+
+	@property({ type: Number })
+	public set width(value: number | undefined) {
+		const oldValue = this.value?.width;
+		if (value !== oldValue) {
+			this.value = { ...this.value, width: value, height: this.value?.height };
+			if (this.locked) this.#updateRatio();
+		}
+	}
+	public get width(): number | undefined {
+		return this.value?.width;
+	}
+
+	@property({ type: Number })
+	public set height(value: number | undefined) {
+		const oldValue = this.value?.height;
+		if (value !== oldValue) {
+			this.value = { ...this.value, width: this.value?.width, height: value };
+			if (this.locked) this.#updateRatio();
+		}
+	}
+	public get height(): number | undefined {
+		return this.value?.height;
+	}
+
+	@property({ type: Boolean })
+	locked = true;
+
+	@property({ type: Boolean })
+	disabled = false;
+
+	@property({ type: Number, attribute: 'natural-width' })
+	naturalWidth?: number;
+
+	@property({ type: Number, attribute: 'natural-height' })
+	naturalHeight?: number;
+
+	override connectedCallback() {
+		super.connectedCallback();
+		this.#updateRatio();
+	}
+
+	#updateRatio() {
+		const width = this.value?.width;
+		const height = this.value?.height;
+		if (width && height) {
+			this.#ratio = width / height;
+		}
+	}
+
+	#onWidthInput(e: UUIInputEvent) {
+		const width = parseInt(e.target.value as string, 10);
+		if (isNaN(width) || width <= 0) return;
+
+		if (this.locked && this.#ratio) {
+			this.value = { width, height: Math.round(width / this.#ratio) };
+		} else {
+			this.value = { ...this.value, width };
+		}
+
+		this.dispatchEvent(new UmbChangeEvent());
+	}
+
+	#onHeightInput(e: UUIInputEvent) {
+		const height = parseInt(e.target.value as string, 10);
+		if (isNaN(height) || height <= 0) return;
+
+		if (this.locked && this.#ratio) {
+			this.value = { width: Math.round(height * this.#ratio), height };
+		} else {
+			this.value = { ...this.value, height };
+		}
+
+		this.dispatchEvent(new UmbChangeEvent());
+	}
+
+	#onToggleLock() {
+		this.locked = !this.locked;
+
+		if (this.locked) {
+			this.#updateRatio();
+		}
+
+		this.dispatchEvent(new UmbChangeEvent());
+	}
+
+	#onReset() {
+		if (!this.naturalWidth || !this.naturalHeight) return;
+
+		this.value = { width: this.naturalWidth, height: this.naturalHeight };
+		this.#ratio = this.naturalWidth / this.naturalHeight;
+		this.locked = true;
+
+		this.dispatchEvent(new UmbChangeEvent());
+	}
+
+	get #hasNaturalDimensions(): boolean {
+		return this.naturalWidth != null && this.naturalHeight != null && this.naturalWidth > 0 && this.naturalHeight > 0;
+	}
+
+	get #isNatural(): boolean {
+		return this.value?.width === this.naturalWidth && this.value?.height === this.naturalHeight;
+	}
+
+	override render() {
+		return html`
+			<div id="dimensions">
+				<div class="dimension-field">
+					<uui-label for="width">${this.localize.term('general_width')}</uui-label>
+					<uui-input
+						id="width"
+						type="number"
+						label=${this.localize.term('general_width')}
+						placeholder=${this.localize.term('general_width')}
+						min="1"
+						.value=${this.value?.width?.toString() ?? ''}
+						?disabled=${this.disabled}
+						@input=${this.#onWidthInput}>
+						<span class="extra" slot="append">px</span>
+					</uui-input>
+				</div>
+				<uui-button
+					compact
+					label=${this.localize.term('general_constrainProportions')}
+					title=${this.localize.term('general_constrainProportions')}
+					look=${this.locked ? 'primary' : 'default'}
+					?disabled=${this.disabled}
+					@click=${this.#onToggleLock}>
+					<uui-icon name=${this.locked ? 'icon-lock' : 'icon-unlocked'}></uui-icon>
+				</uui-button>
+				<div class="dimension-field">
+					<uui-label for="height">${this.localize.term('general_height')}</uui-label>
+					<uui-input
+						id="height"
+						type="number"
+						label=${this.localize.term('general_height')}
+						placeholder=${this.localize.term('general_height')}
+						min="1"
+						.value=${this.value?.height?.toString() ?? ''}
+						?disabled=${this.disabled}
+						@input=${this.#onHeightInput}>
+						<span class="extra" slot="append">px</span>
+					</uui-input>
+				</div>
+			</div>
+			${this.#hasNaturalDimensions && !this.#isNatural
+				? html`<uui-button
+						id="reset"
+						compact
+						label=${this.localize.term('general_reset')}
+						?disabled=${this.disabled}
+						@click=${this.#onReset}></uui-button>`
+				: nothing}
+		`;
+	}
+
+	static override styles = css`
+		#dimensions {
+			display: flex;
+			align-items: end;
+			gap: var(--uui-size-space-3);
+
+			.dimension-field {
+				flex: 1;
+				display: flex;
+				flex-direction: column;
+				gap: var(--uui-size-space-1);
+
+				uui-input {
+					margin-bottom: 0;
+				}
+
+				.extra {
+					user-select: none;
+					height: 100%;
+					padding: 0 var(--uui-size-3);
+					border-left: 1px solid var(--uui-input-border-color, var(--uui-color-border));
+					background: var(--uui-color-background);
+					color: var(--uui-color-text);
+					display: flex;
+					justify-content: center;
+					align-items: center;
+				}
+			}
+		}
+
+		#reset {
+			margin-bottom: var(--uui-size-space-1);
+		}
+	`;
+}
+
+export default UmbInputDimensionsElement;
+
+declare global {
+	interface HTMLElementTagNameMap {
+		'umb-input-dimensions': UmbInputDimensionsElement;
+	}
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dimensions/input-dimensions.test.ts b/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dimensions/input-dimensions.test.ts
new file mode 100644
index 000000000000..af3ca28262bd
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dimensions/input-dimensions.test.ts
@@ -0,0 +1,236 @@
+import { UmbInputDimensionsElement } from './input-dimensions.element.js';
+import { expect, fixture, html, oneEvent } from '@open-wc/testing';
+import { type UmbTestRunnerWindow, defaultA11yConfig } from '@umbraco-cms/internal/test-utils';
+
+describe('UmbInputDimensionsElement', () => {
+	let element: UmbInputDimensionsElement;
+
+	beforeEach(async () => {
+		element = await fixture(html`<umb-input-dimensions></umb-input-dimensions>`);
+	});
+
+	it('is defined with its own instance', () => {
+		expect(element).to.be.instanceOf(UmbInputDimensionsElement);
+	});
+
+	it('renders with initial width/height values', async () => {
+		element = await fixture(html`<umb-input-dimensions .width=${800} .height=${600}></umb-input-dimensions>`);
+		expect(element.width).to.equal(800);
+		expect(element.height).to.equal(600);
+
+		const widthInput = element.shadowRoot!.querySelector<HTMLInputElement>('#width');
+		const heightInput = element.shadowRoot!.querySelector<HTMLInputElement>('#height');
+		expect(widthInput?.value).to.equal('800');
+		expect(heightInput?.value).to.equal('600');
+	});
+
+	it('dispatches change event on width input', async () => {
+		element = await fixture(
+			html`<umb-input-dimensions .width=${100} .height=${100} .locked=${false}></umb-input-dimensions>`,
+		);
+
+		const widthInput = element.shadowRoot!.querySelector<HTMLInputElement>('#width');
+		widthInput!.value = '200';
+		const listener = oneEvent(element, 'change');
+		widthInput!.dispatchEvent(new Event('input'));
+		await listener;
+
+		expect(element.width).to.equal(200);
+	});
+
+	it('dispatches change event on height input', async () => {
+		element = await fixture(
+			html`<umb-input-dimensions .width=${100} .height=${100} .locked=${false}></umb-input-dimensions>`,
+		);
+
+		const heightInput = element.shadowRoot!.querySelector<HTMLInputElement>('#height');
+		heightInput!.value = '300';
+		const listener = oneEvent(element, 'change');
+		heightInput!.dispatchEvent(new Event('input'));
+		await listener;
+
+		expect(element.height).to.equal(300);
+	});
+
+	it('auto-computes height when locked and width changes', async () => {
+		element = await fixture(
+			html`<umb-input-dimensions .width=${800} .height=${400} .locked=${true}></umb-input-dimensions>`,
+		);
+		// Ratio is 800/400 = 2
+
+		const widthInput = element.shadowRoot!.querySelector<HTMLInputElement>('#width');
+		widthInput!.value = '400';
+		const listener = oneEvent(element, 'change');
+		widthInput!.dispatchEvent(new Event('input'));
+		await listener;
+
+		expect(element.width).to.equal(400);
+		expect(element.height).to.equal(200); // 400 / 2
+	});
+
+	it('auto-computes width when locked and height changes', async () => {
+		element = await fixture(
+			html`<umb-input-dimensions .width=${800} .height=${400} .locked=${true}></umb-input-dimensions>`,
+		);
+		// Ratio is 800/400 = 2
+
+		const heightInput = element.shadowRoot!.querySelector<HTMLInputElement>('#height');
+		heightInput!.value = '200';
+		const listener = oneEvent(element, 'change');
+		heightInput!.dispatchEvent(new Event('input'));
+		await listener;
+
+		expect(element.height).to.equal(200);
+		expect(element.width).to.equal(400); // 200 * 2
+	});
+
+	it('does not affect height when unlocked and width changes', async () => {
+		element = await fixture(
+			html`<umb-input-dimensions .width=${800} .height=${400} .locked=${false}></umb-input-dimensions>`,
+		);
+
+		const widthInput = element.shadowRoot!.querySelector<HTMLInputElement>('#width');
+		widthInput!.value = '600';
+		const listener = oneEvent(element, 'change');
+		widthInput!.dispatchEvent(new Event('input'));
+		await listener;
+
+		expect(element.width).to.equal(600);
+		expect(element.height).to.equal(400); // unchanged
+	});
+
+	it('recalculates ratio when locking', async () => {
+		element = await fixture(
+			html`<umb-input-dimensions .width=${800} .height=${400} .locked=${false}></umb-input-dimensions>`,
+		);
+
+		// Change width without lock — height stays
+		const widthInput = element.shadowRoot!.querySelector<HTMLInputElement>('#width');
+		widthInput!.value = '600';
+		widthInput!.dispatchEvent(new Event('input'));
+		await element.updateComplete;
+
+		// Now lock — new ratio should be 600/400 = 1.5
+		const lockButton = element.shadowRoot!.querySelector<HTMLElement>('uui-button[label]');
+		lockButton!.click();
+		await element.updateComplete;
+
+		expect(element.locked).to.be.true;
+
+		// Change width — height should follow new ratio
+		widthInput!.value = '300';
+		const listener = oneEvent(element, 'change');
+		widthInput!.dispatchEvent(new Event('input'));
+		await listener;
+
+		expect(element.width).to.equal(300);
+		expect(element.height).to.equal(200); // 300 / 1.5
+	});
+
+	it('rejects invalid input values', async () => {
+		element = await fixture(
+			html`<umb-input-dimensions .width=${100} .height=${100} .locked=${false}></umb-input-dimensions>`,
+		);
+
+		const widthInput = element.shadowRoot!.querySelector<HTMLInputElement>('#width');
+
+		// Zero
+		widthInput!.value = '0';
+		widthInput!.dispatchEvent(new Event('input'));
+		await element.updateComplete;
+		expect(element.width).to.equal(100); // unchanged
+
+		// Negative
+		widthInput!.value = '-5';
+		widthInput!.dispatchEvent(new Event('input'));
+		await element.updateComplete;
+		expect(element.width).to.equal(100); // unchanged
+
+		// NaN
+		widthInput!.value = 'abc';
+		widthInput!.dispatchEvent(new Event('input'));
+		await element.updateComplete;
+		expect(element.width).to.equal(100); // unchanged
+	});
+
+	it('disables inputs and buttons when disabled', async () => {
+		element = await fixture(
+			html`<umb-input-dimensions .width=${100} .height=${100} .disabled=${true}></umb-input-dimensions>`,
+		);
+
+		const widthInput = element.shadowRoot!.querySelector<HTMLElement>('#width');
+		const heightInput = element.shadowRoot!.querySelector<HTMLElement>('#height');
+		const lockButton = element.shadowRoot!.querySelector<HTMLElement>('uui-button');
+
+		expect(widthInput?.hasAttribute('disabled')).to.be.true;
+		expect(heightInput?.hasAttribute('disabled')).to.be.true;
+		expect(lockButton?.hasAttribute('disabled')).to.be.true;
+	});
+
+	it('does not show reset button when no natural dimensions', async () => {
+		element = await fixture(html`<umb-input-dimensions .width=${100} .height=${100}></umb-input-dimensions>`);
+
+		const buttons = element.shadowRoot!.querySelectorAll('uui-button');
+		// Only the lock button
+		expect(buttons.length).to.equal(1);
+	});
+
+	it('shows reset button when natural dimensions differ from current', async () => {
+		element = await fixture(html`
+			<umb-input-dimensions
+				.width=${400}
+				.height=${300}
+				.naturalWidth=${800}
+				.naturalHeight=${600}>
+			</umb-input-dimensions>
+		`);
+
+		const buttons = element.shadowRoot!.querySelectorAll('uui-button');
+		// Lock button + reset button
+		expect(buttons.length).to.equal(2);
+	});
+
+	it('hides reset button when dimensions match natural', async () => {
+		element = await fixture(html`
+			<umb-input-dimensions
+				.width=${800}
+				.height=${600}
+				.naturalWidth=${800}
+				.naturalHeight=${600}>
+			</umb-input-dimensions>
+		`);
+
+		const buttons = element.shadowRoot!.querySelectorAll('uui-button');
+		// Only lock button, no reset
+		expect(buttons.length).to.equal(1);
+	});
+
+	it('resets to natural dimensions when reset button clicked', async () => {
+		element = await fixture(html`
+			<umb-input-dimensions
+				.width=${400}
+				.height=${300}
+				.naturalWidth=${800}
+				.naturalHeight=${600}
+				.locked=${false}>
+			</umb-input-dimensions>
+		`);
+
+		const buttons = element.shadowRoot!.querySelectorAll('uui-button');
+		const resetButton = buttons[1]; // second button is reset
+
+		const listener = oneEvent(element, 'change');
+		resetButton.click();
+		await listener;
+
+		expect(element.width).to.equal(800);
+		expect(element.height).to.equal(600);
+		expect(element.locked).to.be.true;
+	});
+
+	if ((window as UmbTestRunnerWindow).__UMBRACO_TEST_RUN_A11Y_TEST) {
+		it('passes the a11y audit', async () => {
+			await expect(element).shadowDom.to.be.accessible(defaultA11yConfig);
+		});
+	}
+});
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dropdown/input-dropdown-list.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dropdown/input-dropdown-list.element.ts
index 36fb0751bd69..cd246aed4552 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dropdown/input-dropdown-list.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/components/input-dropdown/input-dropdown-list.element.ts
@@ -2,7 +2,7 @@ import { css, customElement, html, property } from '@umbraco-cms/backoffice/exte
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UMB_VALIDATION_EMPTY_LOCALIZATION_KEY, UmbFormControlMixin } from '@umbraco-cms/backoffice/validation';
-import type { UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 
 @customElement('umb-input-dropdown-list')
 export class UmbInputDropdownListElement extends UmbFormControlMixin<
@@ -11,7 +11,7 @@ export class UmbInputDropdownListElement extends UmbFormControlMixin<
 	undefined
 >(UmbLitElement, undefined) {
 	@property({ type: Array })
-	public set options(value: Array<Option> | undefined) {
+	public set options(value: Array<UUISelectOption> | undefined) {
 		this.#options = value;
 
 		this.value =
@@ -20,10 +20,10 @@ export class UmbInputDropdownListElement extends UmbFormControlMixin<
 				.map((option) => option.value)
 				.join(', ') ?? undefined;
 	}
-	public get options(): Array<Option> | undefined {
+	public get options(): Array<UUISelectOption> | undefined {
 		return this.#options;
 	}
-	#options?: Array<Option> | undefined;
+	#options?: Array<UUISelectOption> | undefined;
 
 	@property({ type: String })
 	public placeholder?: string;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/components/input-time-zone/input-time-zone-picker.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/components/input-time-zone/input-time-zone-picker.element.ts
index 86be2c1a36a6..fa722e19c584 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/components/input-time-zone/input-time-zone-picker.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/components/input-time-zone/input-time-zone-picker.element.ts
@@ -1,6 +1,6 @@
 import { html, customElement, css, property, query, until, repeat, state } from '@umbraco-cms/backoffice/external/lit';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import type { UUIComboboxElement, UUIComboboxEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUIComboboxElement, UUIComboboxEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 import type { UmbTimeZone } from '@umbraco-cms/backoffice/utils';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 import { UmbFormControlMixin } from '@umbraco-cms/backoffice/validation';
@@ -75,7 +75,7 @@ export class UmbInputTimeZonePickerElement extends UmbFormControlMixin<string, t
 		this.dispatchEvent(new UmbChangeEvent());
 	}
 
-	#renderTimeZoneOption = (option: Option) =>
+	#renderTimeZoneOption = (option: UUISelectOption) =>
 		html`<uui-combobox-list-option .value=${option.value} .displayValue=${option.name}>
 			${option.name}
 		</uui-combobox-list-option>`;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-color-picker-input/multiple-color-picker-input.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-color-picker-input/multiple-color-picker-input.element.ts
index bb27d257bfd3..5a8f8ca6643b 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-color-picker-input/multiple-color-picker-input.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-color-picker-input/multiple-color-picker-input.element.ts
@@ -1,6 +1,6 @@
 import type { UmbMultipleColorPickerItemInputElement } from './multiple-color-picker-item-input.element.js';
 import { css, customElement, html, nothing, repeat, property, state } from '@umbraco-cms/backoffice/external/lit';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbSorterController } from '@umbraco-cms/backoffice/sorter';
@@ -12,7 +12,7 @@ import type { UmbSwatchDetails } from '@umbraco-cms/backoffice/models';
  * @element umb-multiple-color-picker-input
  */
 @customElement('umb-multiple-color-picker-input')
-export class UmbMultipleColorPickerInputElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbMultipleColorPickerInputElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	#sorter = new UmbSorterController(this, {
 		getUniqueOfElement: (element: UmbMultipleColorPickerItemInputElement) => {
 			return element.value.toString();
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-color-picker-input/multiple-color-picker-item-input.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-color-picker-input/multiple-color-picker-item-input.element.ts
index 702bbb9620e7..293ce643999c 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-color-picker-input/multiple-color-picker-item-input.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-color-picker-input/multiple-color-picker-item-input.element.ts
@@ -12,14 +12,14 @@ import {
 import { umbConfirmModal } from '@umbraco-cms/backoffice/modal';
 import { UmbChangeEvent, UmbInputEvent, UmbDeleteEvent } from '@umbraco-cms/backoffice/event';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import type { UUIColorPickerElement, UUIInputElement, UUIInputEvent } from '@umbraco-cms/backoffice/external/uui';
 
 /**
  * @element umb-multiple-color-picker-item-input
  */
 @customElement('umb-multiple-color-picker-item-input')
-export class UmbMultipleColorPickerItemInputElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbMultipleColorPickerItemInputElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	@property({ type: String })
 	public override set value(value: string) {
 		this._valueHex = this.#expandHex(value);
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-text-string-input/input-multiple-text-string-item.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-text-string-input/input-multiple-text-string-item.element.ts
index 6d469111a281..32d8163d2ae5 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-text-string-input/input-multiple-text-string-item.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/components/multiple-text-string-input/input-multiple-text-string-item.element.ts
@@ -2,14 +2,14 @@ import { css, customElement, html, nothing, property, query, when } from '@umbra
 import { umbConfirmModal } from '@umbraco-cms/backoffice/modal';
 import { UmbChangeEvent, UmbInputEvent, UmbDeleteEvent } from '@umbraco-cms/backoffice/event';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import type { UUIInputElement, UUIInputEvent } from '@umbraco-cms/backoffice/external/uui';
 
 /**
  * @element umb-input-multiple-text-string-item
  */
 @customElement('umb-input-multiple-text-string-item')
-export class UmbInputMultipleTextStringItemElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbInputMultipleTextStringItemElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	/**
 	 * Disables the input
 	 * @type {boolean}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/culture/components/input-culture-select/input-culture-select.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/culture/components/input-culture-select/input-culture-select.element.ts
index d0bf73cd1e31..7ce27386fab1 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/culture/components/input-culture-select/input-culture-select.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/culture/components/input-culture-select/input-culture-select.element.ts
@@ -2,12 +2,12 @@ import { UmbCultureRepository } from '../../repository/culture.repository.js';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 import { html, repeat, ifDefined, customElement, property, state } from '@umbraco-cms/backoffice/external/lit';
 import type { UUIComboboxElement, UUIComboboxEvent } from '@umbraco-cms/backoffice/external/uui';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import type { CultureReponseModel } from '@umbraco-cms/backoffice/external/backend-api';
 
 @customElement('umb-input-culture-select')
-export class UmbInputCultureSelectElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbInputCultureSelectElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	/**
 	 * Disables the input
 	 * @type {boolean}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/extension/collection/extension-collection.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/extension/collection/extension-collection.element.ts
index 0d84e3875197..15d068a8cb97 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/extension/collection/extension-collection.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/extension/collection/extension-collection.element.ts
@@ -4,13 +4,13 @@ import { fromCamelCase } from '@umbraco-cms/backoffice/utils';
 import { umbExtensionsRegistry } from '@umbraco-cms/backoffice/extension-registry';
 import { UMB_COLLECTION_CONTEXT, UmbCollectionDefaultElement } from '@umbraco-cms/backoffice/collection';
 import type { UmbDefaultCollectionContext } from '@umbraco-cms/backoffice/collection';
-import type { UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 
 @customElement('umb-extension-collection')
 export class UmbExtensionCollectionElement extends UmbCollectionDefaultElement {
 	#collectionContext?: UmbDefaultCollectionContext<UmbExtensionCollectionItemModel, UmbExtensionCollectionFilterModel>;
 
-	#options: Array<Option> = [];
+	#options: Array<UUISelectOption> = [];
 
 	constructor() {
 		super();
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/menu/menu-structure-workspace-context.interface.ts b/src/Umbraco.Web.UI.Client/src/packages/core/menu/menu-structure-workspace-context.interface.ts
index c83b74dc0672..22bf0ff50ba4 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/menu/menu-structure-workspace-context.interface.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/menu/menu-structure-workspace-context.interface.ts
@@ -3,5 +3,17 @@ import type { UmbContext } from '@umbraco-cms/backoffice/class-api';
 import type { Observable } from '@umbraco-cms/backoffice/external/rxjs';
 
 export interface UmbMenuStructureWorkspaceContext extends UmbContext {
+	/**
+	 * Observable array of structure items representing the workspace's breadcrumb hierarchy.
+	 */
 	structure: Observable<UmbStructureItemModel[]>;
+
+	/**
+	 * Returns the href for a breadcrumb structure item, or `undefined` if the item should not be a link.
+	 * Used by the workspace breadcrumb element to generate clickable navigation links.
+	 *
+	 * @param structureItem The structure item to generate an href for.
+	 * @returns The href string, or `undefined` if the item should not be clickable.
+	 */
+	getItemHref(structureItem: UmbStructureItemModel): string | undefined;
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/menu/menu-tree-structure-workspace-context-base.ts b/src/Umbraco.Web.UI.Client/src/packages/core/menu/menu-tree-structure-workspace-context-base.ts
index 8ab7d2e439d1..3ce484ff5880 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/menu/menu-tree-structure-workspace-context-base.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/menu/menu-tree-structure-workspace-context-base.ts
@@ -1,15 +1,19 @@
 import type { ManifestWorkspaceContextMenuStructureKind, UmbStructureItemModel } from './types.js';
 import { UMB_MENU_STRUCTURE_WORKSPACE_CONTEXT } from './menu-structure-workspace-context.context-token.js';
 import { UMB_SECTION_SIDEBAR_MENU_SECTION_CONTEXT } from './section-sidebar-menu/index.js';
-import type { UmbTreeRepository, UmbTreeItemModel, UmbTreeRootModel } from '@umbraco-cms/backoffice/tree';
 import { createExtensionApiByAlias } from '@umbraco-cms/backoffice/extension-registry';
-import { UmbContextBase } from '@umbraco-cms/backoffice/class-api';
-import { UMB_SUBMITTABLE_TREE_ENTITY_WORKSPACE_CONTEXT } from '@umbraco-cms/backoffice/workspace';
+import { linkEntityExpansionEntries } from '@umbraco-cms/backoffice/utils';
 import { UmbArrayState, UmbObjectState } from '@umbraco-cms/backoffice/observable-api';
-import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
 import { UmbAncestorsEntityContext, UmbParentEntityContext, type UmbEntityModel } from '@umbraco-cms/backoffice/entity';
-import { linkEntityExpansionEntries } from '@umbraco-cms/backoffice/utils';
+import { UmbContextBase } from '@umbraco-cms/backoffice/class-api';
 import { UMB_MODAL_CONTEXT } from '@umbraco-cms/backoffice/modal';
+import { UMB_SECTION_CONTEXT } from '@umbraco-cms/backoffice/section';
+import {
+	UMB_SUBMITTABLE_TREE_ENTITY_WORKSPACE_CONTEXT,
+	UMB_WORKSPACE_EDIT_PATH_PATTERN,
+} from '@umbraco-cms/backoffice/workspace';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import type { UmbTreeRepository, UmbTreeItemModel, UmbTreeRootModel } from '@umbraco-cms/backoffice/tree';
 
 interface UmbMenuTreeStructureWorkspaceContextBaseArgs {
 	treeRepositoryAlias: string;
@@ -31,6 +35,8 @@ export abstract class UmbMenuTreeStructureWorkspaceContextBase extends UmbContex
 	 */
 	public readonly parent = this.#parent.asObservable();
 
+	protected _sectionContext?: typeof UMB_SECTION_CONTEXT.TYPE;
+
 	#parentContext = new UmbParentEntityContext(this);
 	#ancestorContext = new UmbAncestorsEntityContext(this);
 	#sectionSidebarMenuContext?: typeof UMB_SECTION_SIDEBAR_MENU_SECTION_CONTEXT.TYPE;
@@ -47,6 +53,10 @@ export abstract class UmbMenuTreeStructureWorkspaceContextBase extends UmbContex
 			this.#isModalContext = modalContext !== undefined;
 		});
 
+		this.consumeContext(UMB_SECTION_CONTEXT, (instance) => {
+			this._sectionContext = instance;
+		});
+
 		this.consumeContext(UMB_SECTION_SIDEBAR_MENU_SECTION_CONTEXT, (instance) => {
 			this.#sectionSidebarMenuContext = instance;
 		});
@@ -77,6 +87,19 @@ export abstract class UmbMenuTreeStructureWorkspaceContextBase extends UmbContex
 		});
 	}
 
+	getItemHref(structureItem: UmbStructureItemModel): string | undefined {
+		if (structureItem.isFolder || !structureItem.unique) return undefined;
+
+		const sectionName = this._sectionContext?.getPathname();
+		if (!sectionName) return undefined;
+
+		return UMB_WORKSPACE_EDIT_PATH_PATTERN.generateAbsolute({
+			sectionName,
+			entityType: structureItem.entityType,
+			unique: structureItem.unique,
+		});
+	}
+
 	async #requestStructure() {
 		const isNew = this.#workspaceContext?.getIsNew();
 		const uniqueObservable = isNew
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/modal/common/error-viewer/error-viewer-modal.token.ts b/src/Umbraco.Web.UI.Client/src/packages/core/modal/common/error-viewer/error-viewer-modal.token.ts
index 18178addd4bf..37be80d1ec5e 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/modal/common/error-viewer/error-viewer-modal.token.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/modal/common/error-viewer/error-viewer-modal.token.ts
@@ -1,8 +1,7 @@
-import type { UmbPeekErrorArgs } from '../../../notification/types.js';
 import { UmbModalToken } from '../../token/index.js';
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface UmbErrorViewerModalData extends UmbPeekErrorArgs {}
+export interface UmbErrorViewerModalData extends Record<string, unknown> {}
 
 export type UmbErrorViewerModalValue = undefined;
 
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/notification/controllers/peek-error/peek-error-notification.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/notification/controllers/peek-error/peek-error-notification.element.ts
index 768581b6b64b..de067b602f0a 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/notification/controllers/peek-error/peek-error-notification.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/notification/controllers/peek-error/peek-error-notification.element.ts
@@ -1,8 +1,14 @@
 import type { UmbNotificationHandler } from '../../notification-handler.js';
 import type { UmbPeekErrorArgs } from '../../types.js';
-import { customElement, html, ifDefined, nothing, property } from '@umbraco-cms/backoffice/external/lit';
+import { css, customElement, html, ifDefined, nothing, property } from '@umbraco-cms/backoffice/external/lit';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import { UMB_ERROR_VIEWER_MODAL, UMB_MODAL_MANAGER_CONTEXT } from '@umbraco-cms/backoffice/modal';
+import {
+	UMB_ERROR_VIEWER_MODAL,
+	UMB_MODAL_MANAGER_CONTEXT,
+	type UmbErrorViewerModalData,
+} from '@umbraco-cms/backoffice/modal';
+
+const DETAIL_MAX_LENGTH = 250;
 
 @customElement('umb-peek-error-notification')
 export class UmbPeekErrorNotificationElement extends UmbLitElement {
@@ -11,31 +17,74 @@ export class UmbPeekErrorNotificationElement extends UmbLitElement {
 
 	public notificationHandler!: UmbNotificationHandler;
 
-	async #onClick() {
+	async #openErrorViewer(data: UmbErrorViewerModalData) {
 		const modalManager = await this.getContext(UMB_MODAL_MANAGER_CONTEXT);
 		if (!modalManager) {
 			throw new Error('Modal manager not found.');
 		}
 
-		modalManager.open(this, UMB_ERROR_VIEWER_MODAL, { data: this.data?.details });
-
+		modalManager.open(this, UMB_ERROR_VIEWER_MODAL, { data });
 		this.notificationHandler.close();
 	}
 
+	get #message() {
+		const detail = this.data?.detail;
+		if (detail && detail.length <= DETAIL_MAX_LENGTH) {
+			return html`${this.data?.message}
+				<p class="detail">${detail}</p>`;
+		}
+		return this.data?.message;
+	}
+
+	get #validationErrors() {
+		return this.data?.errors ?? this.data?.details;
+	}
+
+	get #actions() {
+		const hasLongDetail = !!this.data?.detail && this.data.detail.length > DETAIL_MAX_LENGTH;
+		if (!this.#validationErrors && !hasLongDetail) return nothing;
+
+		return html`
+			${this.#validationErrors
+				? html`<uui-button
+						slot="actions"
+						look="primary"
+						color="danger"
+						label=${this.localize.term('defaultdialogs_seeErrorAction')}
+						@click=${() => this.#openErrorViewer(this.#validationErrors!)}></uui-button>`
+				: nothing}
+			${hasLongDetail
+				? html`<uui-button
+						slot="actions"
+						look="primary"
+						color="danger"
+						label=${this.localize.term('defaultdialogs_exceptionDetail')}
+						@click=${() => {
+							// Cast: the error viewer modal handles strings at runtime, but UmbModalToken constrains data to object types.
+							this.#openErrorViewer(this.data!.detail! as unknown as UmbErrorViewerModalData);
+						}}></uui-button>`
+				: nothing}
+		`;
+	}
+
 	protected override render() {
-		return this.data
-			? html`<uui-toast-notification-layout headline=${ifDefined(this.data.headline)}
-					>${this.data.message}${this.data.details
-						? html`<uui-button
-								slot="actions"
-								look="primary"
-								color="danger"
-								label=${this.localize.term('defaultdialogs_seeErrorAction')}
-								@click=${this.#onClick}></uui-button>`
-						: nothing}</uui-toast-notification-layout
-				>`
-			: nothing;
+		if (!this.data) return nothing;
+		return html`<uui-toast-notification-layout headline=${ifDefined(this.data.headline)}>
+			${this.#message} ${this.#actions}
+		</uui-toast-notification-layout>`;
 	}
+
+	static override readonly styles = [
+		css`
+			.detail {
+				overflow: hidden;
+				text-overflow: ellipsis;
+				display: -webkit-box;
+				-webkit-line-clamp: 3;
+				-webkit-box-orient: vertical;
+			}
+		`,
+	];
 }
 
 declare global {
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/notification/types.ts b/src/Umbraco.Web.UI.Client/src/packages/core/notification/types.ts
index 7e47cd51829e..e4bbe3ca5eb1 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/notification/types.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/notification/types.ts
@@ -6,7 +6,7 @@ export interface UmbNotificationDefaultData {
 	message: string;
 	headline?: string;
 	/**
-	 * @deprecated, do not use this. It will be removed in v.16 — Use UmbPeekError instead
+	 * @deprecated Use {@link UmbPeekErrorArgs} instead. Scheduled for removal in Umbraco 19.
 	 */
 	structuredList?: Record<string, Array<unknown>>;
 	whitespace?: 'normal' | 'pre-line' | 'pre-wrap' | 'nowrap' | 'pre';
@@ -25,8 +25,20 @@ export interface UmbNotificationOptions<UmbNotificationData = UmbNotificationDef
 
 export type UmbNotificationColor = '' | 'default' | 'positive' | 'warning' | 'danger';
 
+/**
+ * Arguments for displaying an error peek notification.
+ * @interface UmbPeekErrorArgs
+ */
 export interface UmbPeekErrorArgs extends UmbNotificationDefaultData {
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	details?: any;
+	/** A human-readable explanation of the error (from ProblemDetails.detail). */
+	detail?: string;
+	/** Validation errors keyed by field name (from ProblemDetails.errors). */
+	errors?: Record<string, string[]>;
+	/**
+	 * Validation errors keyed by field name (from ProblemDetails.errors).
+	 * @deprecated Use `errors` instead. Scheduled for removal in Umbraco 19.
+	 */
+	details?: Record<string, string[]>;
+	/** The notification color. Defaults to 'danger'. */
 	color?: UmbNotificationColor;
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/object-type/input-object-type.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/object-type/input-object-type.element.ts
index 49cec769d60b..704781854d31 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/object-type/input-object-type.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/object-type/input-object-type.element.ts
@@ -1,11 +1,11 @@
 import { UmbObjectTypeRepository } from './object-type.repository.js';
 import { html, customElement, property, query, state } from '@umbraco-cms/backoffice/external/lit';
 import type { UUISelectElement } from '@umbraco-cms/backoffice/external/uui';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 
 @customElement('umb-input-object-type')
-export class UmbInputObjectTypeElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbInputObjectTypeElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	@query('uui-select')
 	private _select!: UUISelectElement;
 
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/property-editor-data-source/input/input-property-editor-data-source.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/property-editor-data-source/input/input-property-editor-data-source.element.ts
index 9687e685c670..7fa82d7bd7cb 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/property-editor-data-source/input/input-property-editor-data-source.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/property-editor-data-source/input/input-property-editor-data-source.element.ts
@@ -6,11 +6,11 @@ import { splitStringToArray } from '@umbraco-cms/backoffice/utils';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbSorterController } from '@umbraco-cms/backoffice/sorter';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import type { UmbRepositoryItemsStatus } from '@umbraco-cms/backoffice/repository';
 
 @customElement('umb-input-property-editor-data-source')
-export class UmbInputPropertyEditorDataSourceElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbInputPropertyEditorDataSourceElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	#sorter = new UmbSorterController<string>(this, {
 		getUniqueOfElement: (element) => {
 			return element.id;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/recycle-bin/entity-action/restore-from-recycle-bin/modal/restore-from-recycle-bin-modal.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/recycle-bin/entity-action/restore-from-recycle-bin/modal/restore-from-recycle-bin-modal.element.ts
index 8abe1888d46e..7a08451be2d7 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/recycle-bin/entity-action/restore-from-recycle-bin/modal/restore-from-recycle-bin-modal.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/recycle-bin/entity-action/restore-from-recycle-bin/modal/restore-from-recycle-bin-modal.element.ts
@@ -37,12 +37,14 @@ export class UmbRestoreFromRecycleBinModalElement extends UmbModalBaseElement<
 
 		const restoreItem = await this.#requestItem(this.data.unique);
 
-		if (this.data.itemDataResolver) {
-			const resolver = new this.data.itemDataResolver(this);
-			resolver.setData(restoreItem);
-			this._restoreItemName = await resolver.getName();
-		} else {
-			this._restoreItemName = restoreItem.name;
+		if (restoreItem) {
+			if (this.data.itemDataResolver) {
+				const resolver = new this.data.itemDataResolver(this);
+				resolver.setData(restoreItem);
+				this._restoreItemName = await resolver.getName();
+			} else {
+				this._restoreItemName = restoreItem.name;
+			}
 		}
 
 		const unique = await this.#requestAutomaticRestoreDestination();
@@ -58,11 +60,14 @@ export class UmbRestoreFromRecycleBinModalElement extends UmbModalBaseElement<
 		// This is a temp solution to show something in the UI.
 		if (unique === null) {
 			this._destinationItemName = 'Root';
+			this._destinationItem = null;
 
 			this.#setDestinationValue({
 				unique: null,
 				entityType: this.data?.destinationRootEntityType ?? this.data?.entityType ?? 'unknown',
 			});
+
+			return;
 		}
 
 		if (unique) {
@@ -168,7 +173,7 @@ export class UmbRestoreFromRecycleBinModalElement extends UmbModalBaseElement<
 			<umb-body-layout headline="Restore">
 				<uui-box>
 					${this._isAutomaticRestore
-						? html` Restore ${this._restoreItemName} to ${this._destinationItemName}`
+						? html`Restore ${this._restoreItemName} to ${this._destinationItemName}`
 						: this.#renderCustomSelectDestination()}
 				</uui-box>
 				${this.#renderActions()}
@@ -181,17 +186,23 @@ export class UmbRestoreFromRecycleBinModalElement extends UmbModalBaseElement<
 			<h4>Cannot automatically restore this item.</h4>
 			<p>There is no location where this item can be automatically restored. You can select a new location below.</p>
 			<h5>Restore to:</h5>
-			${this._destinationItem && this._destinationItemName
-				? html`<uui-ref-node name=${this._destinationItemName}>
-						<uui-action-bar slot="actions">
-							<uui-button @click=${() => (this._destinationItem = undefined)} label="Remove"
-								>${this.localize.term('general_remove')}</uui-button
-							>
-						</uui-action-bar>
-					</uui-ref-node>`
-				: html` <uui-button id="placeholder" look="placeholder" @click=${this.#onSelectCustomDestination}
-						>Select location</uui-button
-					>`}
+			${this._destinationItem !== undefined && this._destinationItemName
+				? html`
+						<uui-ref-node name=${this._destinationItemName}>
+							<uui-action-bar slot="actions">
+								<uui-button
+									@click=${() => (this._destinationItem = undefined)}
+									label=${this.localize.term('general_remove')}></uui-button>
+							</uui-action-bar>
+						</uui-ref-node>
+					`
+				: html`
+						<uui-button
+							id="placeholder"
+							look="placeholder"
+							label="Select location"
+							@click=${this.#onSelectCustomDestination}></uui-button>
+					`}
 		`;
 	}
 
@@ -216,6 +227,6 @@ export default UmbRestoreFromRecycleBinModalElement;
 
 declare global {
 	interface HTMLElementTagNameMap {
-		['umb-restore-from-recycle-bin-modal']: UmbRestoreFromRecycleBinModalElement;
+		'umb-restore-from-recycle-bin-modal': UmbRestoreFromRecycleBinModalElement;
 	}
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/resources/api-interceptor.controller.ts b/src/Umbraco.Web.UI.Client/src/packages/core/resources/api-interceptor.controller.ts
index 58ec81913f36..c3d2fbdc082a 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/resources/api-interceptor.controller.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/resources/api-interceptor.controller.ts
@@ -247,7 +247,7 @@ export class UmbApiInterceptorController extends UmbControllerBase {
 					this.#peekError(
 						notification.category,
 						notification.message,
-						null,
+						undefined,
 						extractUmbNotificationColor(notification.type),
 					);
 				}
@@ -285,9 +285,9 @@ export class UmbApiInterceptorController extends UmbControllerBase {
 
 				// Notify about non-GET 401s after successful re-auth
 				if (this.#nonGet401Requests.length > 0) {
-					const errors: Record<string, string> = {};
+					const errors: Record<string, string[]> = {};
 					this.#nonGet401Requests.forEach((req) => {
-						errors[`${req.request.method} ${req.request.url}`] = `Request failed with 401 Unauthorized.`;
+						errors[`${req.request.method} ${req.request.url}`] = ['Request failed with 401 Unauthorized.'];
 					});
 					this.#peekError(
 						'Some actions were not completed',
@@ -335,10 +335,10 @@ export class UmbApiInterceptorController extends UmbControllerBase {
 	 * Helper to show a notification error.
 	 * @param {string} headline The headline of the error notification.
 	 * @param {string} message The message of the error notification.
-	 * @param {unknown} details Additional details to show in the notification.
+	 * @param {Record<string, string[]>} [errors] Validation errors keyed by field name.
 	 * @param {UmbNotificationColor} [color] The color of the notification.
 	 */
-	async #peekError(headline: string, message: string, details: unknown, color?: UmbNotificationColor) {
+	async #peekError(headline: string, message: string, errors?: Record<string, string[]>, color?: UmbNotificationColor) {
 		// Store the host for usage in the following async context
 		const host = this._host;
 
@@ -346,7 +346,7 @@ export class UmbApiInterceptorController extends UmbControllerBase {
 		(await import('@umbraco-cms/backoffice/notification')).umbPeekError(host, {
 			headline,
 			message,
-			details,
+			errors,
 			color,
 		});
 	}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/resources/resource.controller.ts b/src/Umbraco.Web.UI.Client/src/packages/core/resources/resource.controller.ts
index f66114e5f55e..b1cfdbdfa2f1 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/resources/resource.controller.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/resources/resource.controller.ts
@@ -2,6 +2,7 @@ import { isApiError, isCancelablePromise, isCancelError, isProblemDetailsLike }
 import { UmbApiError, UmbCancelError } from './umb-error.js';
 import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
 import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import type { UmbPeekErrorArgs } from '@umbraco-cms/backoffice/notification';
 
 export class UmbResourceController<T = unknown> extends UmbControllerBase {
 	/**
@@ -73,15 +74,27 @@ export class UmbResourceController<T = unknown> extends UmbControllerBase {
 		this.cancel();
 	}
 
-	protected async _peekError(headline: string, message: string, details: unknown) {
+	/**
+	 * Show an error peek notification to the user.
+	 * @param args - The error notification details.
+	 */
+	protected async _peekError(args: UmbPeekErrorArgs): Promise<void>;
+	/**
+	 * @deprecated Use the overload accepting {@link UmbPeekErrorArgs} instead. Scheduled for removal in Umbraco 19.
+	 */
+	protected async _peekError(headline: string, message: string, errors?: Record<string, string[]>): Promise<void>;
+	protected async _peekError(
+		headlineOrArgs: string | UmbPeekErrorArgs,
+		message?: string,
+		errors?: Record<string, string[]>,
+	): Promise<void> {
+		const args: UmbPeekErrorArgs =
+			typeof headlineOrArgs === 'object' ? headlineOrArgs : { headline: headlineOrArgs, message: message!, errors };
+
 		// Store the host for usage in the following async context
 		const host = this._host;
 
 		// This late importing is done to avoid circular reference
-		(await import('@umbraco-cms/backoffice/notification')).umbPeekError(host, {
-			headline,
-			message,
-			details,
-		});
+		(await import('@umbraco-cms/backoffice/notification')).umbPeekError(host, args);
 	}
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/resources/try-execute/try-execute.controller.ts b/src/Umbraco.Web.UI.Client/src/packages/core/resources/try-execute/try-execute.controller.ts
index 46e016ba5c03..3f54c1e9dfa3 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/resources/try-execute/try-execute.controller.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/resources/try-execute/try-execute.controller.ts
@@ -57,9 +57,11 @@ export class UmbTryExecuteController<T> extends UmbResourceController<T> {
 			return;
 		}
 
-		let headline = 'An error occurred';
+		/** This is a constant on purpose, because the headline should not change. We cannot trust the error details to provide a reliable headline. */
+		const headline = 'An error occurred';
 		let message = 'A fatal server error occurred. If this continues, please reach out to your administrator.';
-		let details: Record<string, string[]> | undefined = undefined;
+		let detail: string | undefined;
+		let errors: Record<string, string[]> | undefined;
 
 		const apiError = error as UmbApiError;
 
@@ -82,15 +84,16 @@ export class UmbTryExecuteController<T> extends UmbResourceController<T> {
 
 			// UmbProblemDetails, show notification
 			message = apiError.problemDetails.title;
-			details = apiError.problemDetails.errors ?? undefined;
+			detail = apiError.problemDetails.detail;
+			errors = apiError.problemDetails.errors;
 
 			// Special handling for ObjectCacheAppCache corruption errors, which we are investigating
 			if (
 				apiError.problemDetails.detail?.includes('ObjectCacheAppCache') ||
 				apiError.problemDetails.detail?.includes('Umbraco.Cms.Infrastructure.Scoping.Scope.DisposeLastScope()')
 			) {
-				headline = 'Please restart the server';
-				message =
+				message = 'Please restart the server';
+				detail =
 					'The Umbraco object cache is corrupt, but your action may still have been executed. Please restart the server to reset the cache. This is a work in progress.';
 			}
 		} else {
@@ -98,7 +101,7 @@ export class UmbTryExecuteController<T> extends UmbResourceController<T> {
 			message = apiError instanceof Error ? apiError.message : 'An unknown error occurred.';
 		}
 
-		this._peekError(headline, message, details);
+		this._peekError({ headline, message, detail, errors });
 		console.error('[UmbTryExecuteController] Error in request:', error);
 	}
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/search/examine-management-dashboard/views/section-view-examine-indexers.ts b/src/Umbraco.Web.UI.Client/src/packages/core/search/examine-management-dashboard/views/section-view-examine-indexers.ts
index 68880c2dba15..f248328dfd36 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/search/examine-management-dashboard/views/section-view-examine-indexers.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/search/examine-management-dashboard/views/section-view-examine-indexers.ts
@@ -127,7 +127,9 @@ export class UmbDashboardExamineIndexElement extends UmbLitElement {
 	#renderIndexSearch() {
 		// Do we want to show the search while rebuilding?
 		if (!this._indexData || this._indexData.healthStatus.status === HealthStatusModel.REBUILDING) return nothing;
-		return html`<umb-dashboard-examine-searcher .searcherName="${this.indexName}"></umb-dashboard-examine-searcher>`;
+		return html`<umb-dashboard-examine-searcher
+			.searcherName=${this.indexName}
+			.uniqueKeyFieldName=${this._indexData?.uniqueKeyFieldName ?? undefined}></umb-dashboard-examine-searcher>`;
 	}
 
 	#renderPropertyList() {
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/search/examine-management-dashboard/views/section-view-examine-searchers.ts b/src/Umbraco.Web.UI.Client/src/packages/core/search/examine-management-dashboard/views/section-view-examine-searchers.ts
index b43b03a56d5a..323cc36e6af4 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/search/examine-management-dashboard/views/section-view-examine-searchers.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/search/examine-management-dashboard/views/section-view-examine-searchers.ts
@@ -5,7 +5,7 @@ import { css, html, nothing, customElement, state, query, property } from '@umbr
 import { umbOpenModal } from '@umbraco-cms/backoffice/modal';
 import { UMB_WORKSPACE_MODAL } from '@umbraco-cms/backoffice/workspace';
 import { UmbModalRouteRegistrationController } from '@umbraco-cms/backoffice/router';
-import { SearcherService } from '@umbraco-cms/backoffice/external/backend-api';
+import { IndexerService, SearcherService } from '@umbraco-cms/backoffice/external/backend-api';
 import { UmbLitElement, umbFocus } from '@umbraco-cms/backoffice/lit-element';
 import { tryExecute } from '@umbraco-cms/backoffice/resources';
 import { UmbPaginationManager } from '@umbraco-cms/backoffice/utils';
@@ -21,6 +21,12 @@ export class UmbDashboardExamineSearcherElement extends UmbLitElement {
 	@property()
 	searcherName!: string;
 
+	@property()
+	uniqueKeyFieldName?: string | null;
+
+	@state()
+	private _resolvedUniqueKeyFieldName: string = '__Key';
+
 	@state()
 	private _searchResults?: UmbSearchResultModel[];
 
@@ -73,6 +79,33 @@ export class UmbDashboardExamineSearcherElement extends UmbLitElement {
 			});
 	}
 
+	override connectedCallback() {
+		super.connectedCallback();
+		this.#resolveUniqueKeyFieldName();
+	}
+
+	override willUpdate(changedProperties: Map<string, unknown>) {
+		super.willUpdate(changedProperties);
+		if (changedProperties.has('uniqueKeyFieldName') && this.uniqueKeyFieldName) {
+			this._resolvedUniqueKeyFieldName = this.uniqueKeyFieldName;
+		}
+	}
+
+	async #resolveUniqueKeyFieldName() {
+		if (this.uniqueKeyFieldName) {
+			this._resolvedUniqueKeyFieldName = this.uniqueKeyFieldName;
+			return;
+		}
+
+		// When rendered standalone (via route), the searcher name typically matches the index name.
+		// If the index is not found (e.g. composite searchers), we fall back to '__Key'.
+		const { data } = await tryExecute(
+			this,
+			IndexerService.getIndexerByIndexName({ path: { indexName: this.searcherName } }),
+		);
+		this._resolvedUniqueKeyFieldName = data?.uniqueKeyFieldName ?? '__Key';
+	}
+
 	private async _onSearch() {
 		if (!this._searchInput.value.length) return;
 		this._searchLoading = true;
@@ -216,7 +249,7 @@ export class UmbDashboardExamineSearcherElement extends UmbLitElement {
 						${this._searchResults?.map((rowData) => {
 							const indexType = rowData.fields?.find((field) => field.name === '__IndexType')?.values?.join(', ') ?? '';
 							this.#entityType = this.#getEntityTypeFromIndexType(indexType);
-							const unique = rowData.fields?.find((field) => field.name === '__Key')?.values?.join(', ') ?? '';
+							const unique = rowData.fields?.find((field) => field.name === this._resolvedUniqueKeyFieldName)?.values?.join(', ') ?? '';
 
 							return html`<uui-table-row>
 								<uui-table-cell> ${rowData.score} </uui-table-cell>
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/themes/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/core/themes/manifests.ts
index 25716a128b34..9fea70ea22f5 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/themes/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/themes/manifests.ts
@@ -11,18 +11,26 @@ export const themes: Array<UmbExtensionManifest> = [
 		name: 'Light',
 		weight: 300,
 	},
+	/*
+	 * The CSS paths below reference theme files provided by @umbraco-ui/uui.
+	 * These files are copied into /umbraco/backoffice/css/ during build by:
+	 *   - vite.config.ts (dev server): copies node_modules/@umbraco-ui/uui/dist/themes/*
+	 *   - src/external/uui/vite.config.ts (production build): copies the same files into dist-cms/css/
+	 *
+	 * If UUI adds, removes, or renames theme files, update the entries here to match.
+	 */
 	{
 		type: 'theme',
 		alias: 'umb-dark-theme',
 		name: 'Dark (Experimental)',
-		css: '/umbraco/backoffice/css/dark.theme.css',
+		css: '/umbraco/backoffice/css/dark.css',
 		weight: 200,
 	},
 	{
 		type: 'theme',
 		alias: 'umb-high-contrast-theme',
 		name: 'High contrast (Experimental)',
-		css: '/umbraco/backoffice/css/high-contrast.theme.css',
+		css: '/umbraco/backoffice/css/high-contrast.css',
 		weight: 100,
 	},
 ];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/utils/date/date.timezone.ts b/src/Umbraco.Web.UI.Client/src/packages/core/utils/date/date.timezone.ts
index 00eb69b387c5..72fbef9ebd3a 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/utils/date/date.timezone.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/utils/date/date.timezone.ts
@@ -83,3 +83,15 @@ export function isEquivalentTimeZone(tz1: string, tz2: string): boolean {
 	const tz2Name = new Intl.DateTimeFormat(undefined, { timeZone: tz2 }).resolvedOptions().timeZone;
 	return tz1Name === tz2Name;
 }
+/**
+ * Default date and time format options for displaying dates.
+ * This can be used with Intl.DateTimeFormat to ensure consistent formatting.
+ */
+export const UMB_DATE_TIME_FORMAT_OPTIONS: Intl.DateTimeFormatOptions = {
+	year: 'numeric',
+	month: 'long',
+	day: 'numeric',
+	hour: 'numeric',
+	minute: 'numeric',
+	second: 'numeric',
+};
diff --git a/src/Umbraco.Web.UI.Client/src/packages/core/workspace/components/workspace-breadcrumb/workspace-menu-breadcrumb/workspace-menu-breadcrumb.element.ts b/src/Umbraco.Web.UI.Client/src/packages/core/workspace/components/workspace-breadcrumb/workspace-menu-breadcrumb/workspace-menu-breadcrumb.element.ts
index 545e74084d41..eee05d563897 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/core/workspace/components/workspace-breadcrumb/workspace-menu-breadcrumb/workspace-menu-breadcrumb.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/core/workspace/components/workspace-breadcrumb/workspace-menu-breadcrumb/workspace-menu-breadcrumb.element.ts
@@ -1,10 +1,8 @@
 import { UMB_WORKSPACE_CONTEXT } from '../../../workspace.context-token.js';
-import { UMB_WORKSPACE_EDIT_PATH_PATTERN } from '../../../paths.js';
 import { css, customElement, html, ifDefined, map, state } from '@umbraco-cms/backoffice/external/lit';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
 import { UMB_MENU_STRUCTURE_WORKSPACE_CONTEXT } from '@umbraco-cms/backoffice/menu';
-import { UMB_SECTION_CONTEXT } from '@umbraco-cms/backoffice/section';
 import type { UmbMenuStructureWorkspaceContext, UmbStructureItemModel } from '@umbraco-cms/backoffice/menu';
 
 @customElement('umb-workspace-breadcrumb')
@@ -20,16 +18,11 @@ export class UmbWorkspaceBreadcrumbElement extends UmbLitElement {
 
 	// TODO: figure out the correct context type
 	#workspaceContext?: any;
-	#sectionContext?: typeof UMB_SECTION_CONTEXT.TYPE;
 	#structureContext?: typeof UMB_MENU_STRUCTURE_WORKSPACE_CONTEXT.TYPE;
 
 	constructor() {
 		super();
 
-		this.consumeContext(UMB_SECTION_CONTEXT, (instance) => {
-			this.#sectionContext = instance;
-		});
-
 		this.consumeContext(UMB_WORKSPACE_CONTEXT, (instance) => {
 			this.#workspaceContext = instance as any;
 			this.#observeIsNew();
@@ -78,16 +71,7 @@ export class UmbWorkspaceBreadcrumbElement extends UmbLitElement {
 	}
 
 	#getHref(structureItem: UmbStructureItemModel) {
-		if (structureItem.isFolder || !structureItem.unique) return undefined;
-
-		const sectionName = this.#sectionContext?.getPathname();
-		if (!sectionName) return undefined;
-
-		return UMB_WORKSPACE_EDIT_PATH_PATTERN.generateAbsolute({
-			sectionName,
-			entityType: structureItem.entityType,
-			unique: structureItem.unique,
-		});
+		return this.#structureContext?.getItemHref?.(structureItem);
 	}
 
 	override render() {
diff --git a/src/Umbraco.Web.UI.Client/src/packages/data-type/components/data-type-input/data-type-input.element.ts b/src/Umbraco.Web.UI.Client/src/packages/data-type/components/data-type-input/data-type-input.element.ts
index 5d09941fc73a..5b7c34c158c8 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/data-type/components/data-type-input/data-type-input.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/data-type/components/data-type-input/data-type-input.element.ts
@@ -5,11 +5,11 @@ import { splitStringToArray } from '@umbraco-cms/backoffice/utils';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbSorterController } from '@umbraco-cms/backoffice/sorter';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 
 // TODO: Rename to 'umb-input-data-type'. [LK]
 @customElement('umb-data-type-input')
-export class UmbDataTypeInputElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbDataTypeInputElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	#sorter = new UmbSorterController<string>(this, {
 		getUniqueOfElement: (element) => {
 			return element.id;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/index.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/index.ts
new file mode 100644
index 000000000000..3d76f338dddc
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/index.ts
@@ -0,0 +1 @@
+export * from './repository/index.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/info-app/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/info-app/manifests.ts
new file mode 100644
index 000000000000..085881a211a1
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/info-app/manifests.ts
@@ -0,0 +1,21 @@
+import { UMB_DOCUMENT_BLUEPRINT_WORKSPACE_ALIAS } from '../../workspace/constants.js';
+import { UMB_DOCUMENT_BLUEPRINT_AUDIT_LOG_REPOSITORY_ALIAS } from '../repository/constants.js';
+import { UMB_WORKSPACE_CONDITION_ALIAS } from '@umbraco-cms/backoffice/workspace';
+
+export const manifests: Array<UmbExtensionManifest> = [
+	{
+		type: 'workspaceInfoApp',
+		kind: 'auditLog',
+		name: 'Document Blueprint History Workspace Info App',
+		alias: 'Umb.WorkspaceInfoApp.DocumentBlueprint.History',
+		meta: {
+			auditLogRepositoryAlias: UMB_DOCUMENT_BLUEPRINT_AUDIT_LOG_REPOSITORY_ALIAS,
+		},
+		conditions: [
+			{
+				alias: UMB_WORKSPACE_CONDITION_ALIAS,
+				match: UMB_DOCUMENT_BLUEPRINT_WORKSPACE_ALIAS,
+			},
+		],
+	},
+];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/manifests.ts
new file mode 100644
index 000000000000..d804039738aa
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/manifests.ts
@@ -0,0 +1,4 @@
+import { manifests as infoAppManifests } from './info-app/manifests.js';
+import { manifests as repositoryManifests } from './repository/manifests.js';
+
+export const manifests: Array<UmbExtensionManifest> = [...infoAppManifests, ...repositoryManifests];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/constants.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/constants.ts
new file mode 100644
index 000000000000..0a58bf37a6bf
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/constants.ts
@@ -0,0 +1 @@
+export const UMB_DOCUMENT_BLUEPRINT_AUDIT_LOG_REPOSITORY_ALIAS = 'Umb.Repository.DocumentBlueprint.AuditLog';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/document-blueprint-audit-log.repository.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/document-blueprint-audit-log.repository.ts
new file mode 100644
index 000000000000..f1540346d267
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/document-blueprint-audit-log.repository.ts
@@ -0,0 +1,93 @@
+import { UmbDocumentBlueprintAuditLogServerDataSource } from './document-blueprint-audit-log.server.data-source.js';
+import type { UmbDocumentBlueprintAuditLogModel } from './types.js';
+import type {
+	UmbAuditLogRepository,
+	UmbAuditLogRequestArgs,
+	UmbAuditLogTagData,
+} from '@umbraco-cms/backoffice/audit-log';
+import { UmbRepositoryBase } from '@umbraco-cms/backoffice/repository';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+
+const UmbDocumentBlueprintAuditLog = Object.freeze({
+	CUSTOM: 'Custom',
+	MOVE: 'Move',
+	NEW: 'New',
+	OPEN: 'Open',
+	SAVE_VARIANT: 'SaveVariant',
+	SAVE: 'Save',
+	SYSTEM: 'System',
+});
+
+/**
+ * Repository for the document blueprint audit log.
+ * @class UmbDocumentBlueprintAuditLogRepository
+ * @augments {UmbRepositoryBase}
+ */
+export class UmbDocumentBlueprintAuditLogRepository
+	extends UmbRepositoryBase
+	implements UmbAuditLogRepository<UmbDocumentBlueprintAuditLogModel>
+{
+	#dataSource: UmbDocumentBlueprintAuditLogServerDataSource;
+
+	/**
+	 * Creates an instance of UmbDocumentBlueprintAuditLogRepository.
+	 * @param {UmbControllerHost} host - The controller host for this controller to be appended to
+	 * @memberof UmbDocumentBlueprintAuditLogRepository
+	 */
+	constructor(host: UmbControllerHost) {
+		super(host);
+		this.#dataSource = new UmbDocumentBlueprintAuditLogServerDataSource(host);
+	}
+
+	/**
+	 * Request the audit log for a document blueprint.
+	 * @param {UmbAuditLogRequestArgs} args
+	 * @returns {*}
+	 * @memberof UmbDocumentBlueprintAuditLogRepository
+	 */
+	async requestAuditLog(args: UmbAuditLogRequestArgs) {
+		return this.#dataSource.getAuditLog(args);
+	}
+
+	/**
+	 * Get the tag style and localization data for a given audit log type.
+	 * @param {string} logType
+	 * @returns {UmbAuditLogTagData}
+	 * @memberof UmbDocumentBlueprintAuditLogRepository
+	 */
+	getTagStyleAndText(logType: string): UmbAuditLogTagData {
+		switch (logType) {
+			case UmbDocumentBlueprintAuditLog.SAVE:
+				return {
+					style: { look: 'primary', color: 'default' },
+					text: { label: 'auditTrails_smallSave', desc: 'auditTrails_save' },
+				};
+
+			case UmbDocumentBlueprintAuditLog.SAVE_VARIANT:
+				return {
+					style: { look: 'primary', color: 'default' },
+					text: { label: 'auditTrails_smallSaveVariant', desc: 'auditTrails_savevariant' },
+				};
+
+			case UmbDocumentBlueprintAuditLog.MOVE:
+				return {
+					style: { look: 'secondary', color: 'default' },
+					text: { label: 'auditTrails_smallMove', desc: 'auditTrails_move' },
+				};
+
+			case UmbDocumentBlueprintAuditLog.CUSTOM:
+				return {
+					style: { look: 'placeholder', color: 'default' },
+					text: { label: 'auditTrails_smallCustom', desc: 'auditTrails_custom' },
+				};
+
+			default:
+				return {
+					style: { look: 'placeholder', color: 'default' },
+					text: { label: logType, desc: '' },
+				};
+		}
+	}
+}
+
+export { UmbDocumentBlueprintAuditLogRepository as api };
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/document-blueprint-audit-log.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/document-blueprint-audit-log.server.data-source.ts
new file mode 100644
index 000000000000..bfb0ae5545e0
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/document-blueprint-audit-log.server.data-source.ts
@@ -0,0 +1,47 @@
+import type { UmbDocumentBlueprintAuditLogModel, UmbDocumentBlueprintAuditLogType } from './types.js';
+import type { UmbAuditLogDataSource, UmbAuditLogRequestArgs } from '@umbraco-cms/backoffice/audit-log';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import type { DirectionModel } from '@umbraco-cms/backoffice/external/backend-api';
+import { DocumentBlueprintService } from '@umbraco-cms/backoffice/external/backend-api';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
+
+export class UmbDocumentBlueprintAuditLogServerDataSource
+	implements UmbAuditLogDataSource<UmbDocumentBlueprintAuditLogModel>
+{
+	#host: UmbControllerHost;
+
+	constructor(host: UmbControllerHost) {
+		this.#host = host;
+	}
+
+	async getAuditLog(args: UmbAuditLogRequestArgs) {
+		const { data, error } = await tryExecute(
+			this.#host,
+			DocumentBlueprintService.getDocumentBlueprintByIdAuditLog({
+				path: { id: args.unique },
+				query: {
+					orderDirection: args.orderDirection as DirectionModel,
+					sinceDate: args.sinceDate,
+					skip: args.skip,
+					take: args.take,
+				},
+			}),
+		);
+
+		if (data) {
+			const mappedItems: Array<UmbDocumentBlueprintAuditLogModel> = (data.items ?? []).map((item) => {
+				return {
+					user: { unique: item.user.id },
+					timestamp: item.timestamp,
+					logType: item.logType as UmbDocumentBlueprintAuditLogType,
+					comment: item.comment,
+					parameters: item.parameters,
+				};
+			});
+
+			return { data: { items: mappedItems, total: data.total } };
+		}
+
+		return { error };
+	}
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/index.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/index.ts
new file mode 100644
index 000000000000..216253b6665a
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/index.ts
@@ -0,0 +1,2 @@
+export { UMB_DOCUMENT_BLUEPRINT_AUDIT_LOG_REPOSITORY_ALIAS } from './constants.js';
+export { UmbDocumentBlueprintAuditLogRepository } from './document-blueprint-audit-log.repository.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/manifests.ts
new file mode 100644
index 000000000000..5a21ff6e01cc
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/manifests.ts
@@ -0,0 +1,10 @@
+import { UMB_DOCUMENT_BLUEPRINT_AUDIT_LOG_REPOSITORY_ALIAS } from './constants.js';
+
+export const manifests: Array<UmbExtensionManifest> = [
+	{
+		type: 'repository',
+		alias: UMB_DOCUMENT_BLUEPRINT_AUDIT_LOG_REPOSITORY_ALIAS,
+		name: 'Document Blueprint Audit Log Repository',
+		api: () => import('./document-blueprint-audit-log.repository.js'),
+	},
+];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/types.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/types.ts
new file mode 100644
index 000000000000..4929b1f59481
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/audit-log/repository/types.ts
@@ -0,0 +1,5 @@
+import type { UmbAuditLogModel, UmbAuditLogType } from '@umbraco-cms/backoffice/audit-log';
+
+export type UmbDocumentBlueprintAuditLogType = 'New' | 'Save' | 'SaveVariant' | 'Open' | 'Move' | UmbAuditLogType;
+
+export type UmbDocumentBlueprintAuditLogModel = UmbAuditLogModel<UmbDocumentBlueprintAuditLogType>;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/index.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/index.ts
index a5e20e96523c..c71ee32767a7 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/index.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/index.ts
@@ -1,5 +1,6 @@
 export * from './constants.js';
-export * from './repository/index.js';
 export * from './entity.js';
+export * from './audit-log/index.js';
+export * from './repository/index.js';
 
 export type * from './types.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/manifests.ts
index deeb26af5e97..97fbc6c822c6 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/manifests.ts
@@ -1,3 +1,4 @@
+import { manifests as auditLogManifests } from './audit-log/manifests.js';
 import { manifests as entityActionManifests } from './entity-actions/manifests.js';
 import { manifests as menuManifests } from './menu/manifests.js';
 import { manifests as repositoryManifests } from './repository/manifests.js';
@@ -7,6 +8,7 @@ import * as entryPointModule from './entry-point.js';
 import type { UmbExtensionManifestKind } from '@umbraco-cms/backoffice/extension-registry';
 
 export const manifests: Array<UmbExtensionManifest | UmbExtensionManifestKind> = [
+	...auditLogManifests,
 	...entityActionManifests,
 	...menuManifests,
 	...repositoryManifests,
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/property-dataset-context/document-blueprint-property-dataset-context.token.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/property-dataset-context/document-blueprint-property-dataset-context.token.ts
index dfe0dc745a33..7ef1e18e8183 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/property-dataset-context/document-blueprint-property-dataset-context.token.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/property-dataset-context/document-blueprint-property-dataset-context.token.ts
@@ -11,4 +11,4 @@ export const IsDocumentBlueprintPropertyDatasetContext = (
 export const UMB_DOCUMENT_BLUEPRINT_PROPERTY_DATASET_CONTEXT = new UmbContextToken<
 	UmbPropertyDatasetContext,
 	UmbDocumentBlueprintPropertyDatasetContext
->('UmbVariantContext', undefined, IsDocumentBlueprintPropertyDatasetContext);
+>('UmbPropertyDatasetContext', undefined, IsDocumentBlueprintPropertyDatasetContext);
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/workspace/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/workspace/manifests.ts
index 87c6af6b726b..cc4c0cbf0ce0 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/workspace/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/workspace/manifests.ts
@@ -31,7 +31,24 @@ export const manifests: Array<UmbExtensionManifest> = [
 			},
 		],
 	},
-
+	{
+		type: 'workspaceView',
+		alias: 'Umb.WorkspaceView.DocumentBlueprint.Info',
+		name: 'Document Blueprint Workspace Info View',
+		element: () => import('./views/info/document-blueprint-workspace-view-info.element.js'),
+		weight: 100,
+		meta: {
+			label: '#general_info',
+			pathname: 'info',
+			icon: 'info',
+		},
+		conditions: [
+			{
+				alias: UMB_WORKSPACE_CONDITION_ALIAS,
+				match: UMB_DOCUMENT_BLUEPRINT_WORKSPACE_ALIAS,
+			},
+		],
+	},
 	{
 		type: 'workspaceAction',
 		kind: 'default',
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/workspace/views/info/document-blueprint-workspace-view-info.element.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/workspace/views/info/document-blueprint-workspace-view-info.element.ts
new file mode 100644
index 000000000000..57c33b8e7f9d
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-blueprints/workspace/views/info/document-blueprint-workspace-view-info.element.ts
@@ -0,0 +1,198 @@
+import type { UmbDocumentBlueprintVariantModel } from '../../../types.js';
+import { UMB_DOCUMENT_BLUEPRINT_PROPERTY_DATASET_CONTEXT } from '../../../property-dataset-context/document-blueprint-property-dataset-context.token.js';
+import { UMB_DOCUMENT_BLUEPRINT_WORKSPACE_CONTEXT } from '../../constants.js';
+import { css, customElement, html, ifDefined, nothing, state } from '@umbraco-cms/backoffice/external/lit';
+import { createExtensionApiByAlias } from '@umbraco-cms/backoffice/extension-registry';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { UmbModalRouteRegistrationController } from '@umbraco-cms/backoffice/router';
+import { UMB_DATE_TIME_FORMAT_OPTIONS } from '@umbraco-cms/backoffice/utils';
+import { UMB_SECTION_USER_PERMISSION_CONDITION_ALIAS } from '@umbraco-cms/backoffice/section';
+import { UMB_SETTINGS_SECTION_ALIAS } from '@umbraco-cms/backoffice/settings';
+import { UMB_WORKSPACE_MODAL } from '@umbraco-cms/backoffice/workspace';
+import type { UmbModalRouteBuilder } from '@umbraco-cms/backoffice/router';
+import type { UmbWorkspaceViewElement } from '@umbraco-cms/backoffice/workspace';
+
+@customElement('umb-document-blueprint-workspace-view-info')
+export class UmbDocumentBlueprintWorkspaceViewInfoElement extends UmbLitElement implements UmbWorkspaceViewElement {
+	@state()
+	private _documentBlueprintUnique = '';
+
+	@state()
+	private _routeBuilder?: UmbModalRouteBuilder;
+
+	@state()
+	private _documentTypeUnique?: string = '';
+
+	@state()
+	private _documentTypeName?: string;
+
+	@state()
+	private _documentTypeIcon?: string;
+
+	@state()
+	private _hasSettingsAccess: boolean = false;
+
+	@state()
+	private _variant?: UmbDocumentBlueprintVariantModel;
+
+	#workspaceContext?: typeof UMB_DOCUMENT_BLUEPRINT_WORKSPACE_CONTEXT.TYPE;
+
+	constructor() {
+		super();
+
+		new UmbModalRouteRegistrationController(this, UMB_WORKSPACE_MODAL)
+			.addAdditionalPath('general/:entityType')
+			.onSetup((params) => {
+				return { data: { entityType: params.entityType, preset: {} } };
+			})
+			.observeRouteBuilder((routeBuilder) => {
+				this._routeBuilder = routeBuilder;
+			});
+
+		this.consumeContext(UMB_DOCUMENT_BLUEPRINT_WORKSPACE_CONTEXT, (context) => {
+			this.#workspaceContext = context;
+			this._documentTypeUnique = this.#workspaceContext?.getContentTypeUnique();
+			this._documentBlueprintUnique = this.#workspaceContext?.getUnique() ?? '';
+			this.#observeContent();
+		});
+
+		this.consumeContext(UMB_DOCUMENT_BLUEPRINT_PROPERTY_DATASET_CONTEXT, (context) => {
+			this.observe(context?.currentVariant, (currentVariant) => {
+				this._variant = currentVariant;
+			});
+		});
+
+		createExtensionApiByAlias(this, UMB_SECTION_USER_PERMISSION_CONDITION_ALIAS, [
+			{
+				config: {
+					match: UMB_SETTINGS_SECTION_ALIAS,
+				},
+				onChange: (permitted: boolean) => {
+					this._hasSettingsAccess = permitted;
+				},
+			},
+		]);
+	}
+
+	#observeContent() {
+		if (!this.#workspaceContext) return;
+
+		this.observe(
+			this.#workspaceContext.structure.ownerContentType,
+			(documentType) => {
+				this._documentTypeName = documentType?.name;
+				this._documentTypeIcon = documentType?.icon;
+			},
+			'_documentType',
+		);
+
+		this.observe(
+			this.#workspaceContext.unique,
+			(unique) => {
+				this._documentBlueprintUnique = unique!;
+			},
+			'_documentBlueprintUnique',
+		);
+	}
+
+	override render() {
+		return html`
+			<div class="container">
+				<umb-extension-slot id="workspace-info-apps" type="workspaceInfoApp"></umb-extension-slot>
+			</div>
+			<div class="container">
+				<uui-box headline=${this.localize.term('general_general')} id="general-section">
+					${this.#renderGeneralSection()}
+				</uui-box>
+			</div>
+		`;
+	}
+
+	#renderGeneralSection() {
+		const editDocumentTypePath = this._routeBuilder?.({ entityType: 'document-type' }) ?? '';
+
+		return html`${this.#renderCreateDate()} ${this.#renderUpdateDate()}
+
+			<div class="general-item">
+				<strong><umb-localize key="content_documentType">Document Type</umb-localize></strong>
+				<uui-ref-node-document-type
+					standalone
+					href=${ifDefined(
+						this._hasSettingsAccess ? editDocumentTypePath + 'edit/' + this._documentTypeUnique : undefined,
+					)}
+					?readonly=${!this._hasSettingsAccess}
+					name=${ifDefined(this.localize.string(this._documentTypeName ?? ''))}>
+					<umb-icon slot="icon" name=${ifDefined(this._documentTypeIcon)}></umb-icon>
+				</uui-ref-node-document-type>
+			</div>
+			<div class="general-item">
+				<strong><umb-localize key="template_id">Id</umb-localize></strong>
+				<span>${this._documentBlueprintUnique}</span>
+			</div>`;
+	}
+
+	#renderCreateDate() {
+		if (!this._variant?.createDate) return nothing;
+		return this.#renderDate(this._variant.createDate, 'content_createDate', 'Created');
+	}
+
+	#renderUpdateDate() {
+		if (!this._variant?.updateDate) return nothing;
+		return this.#renderDate(this._variant.updateDate, 'content_updateDate', 'Last edited');
+	}
+
+	#renderDate(date: string, labelKey: string, labelText: string) {
+		return html`
+			<div class="general-item">
+				<strong><umb-localize .key=${labelKey}>${labelText}</umb-localize></strong>
+				<span>
+					<umb-localize-date .date=${date} .options=${UMB_DATE_TIME_FORMAT_OPTIONS}></umb-localize-date>
+				</span>
+			</div>
+		`;
+	}
+	static override styles = [
+		css`
+			:host {
+				display: grid;
+				gap: var(--uui-size-layout-1);
+				padding: var(--uui-size-layout-1);
+				grid-template-columns: 1fr 350px;
+			}
+
+			div.container {
+				display: flex;
+				flex-direction: column;
+				gap: var(--uui-size-layout-1);
+			}
+
+			#general-section {
+				display: flex;
+				flex-direction: column;
+			}
+
+			.general-item {
+				display: flex;
+				flex-direction: column;
+				gap: var(--uui-size-space-1);
+			}
+
+			.general-item:not(:last-child) {
+				margin-bottom: var(--uui-size-space-6);
+			}
+
+			uui-ref-node-document-type[readonly] {
+				padding-top: 7px;
+				padding-bottom: 7px;
+			}
+		`,
+	];
+}
+
+export default UmbDocumentBlueprintWorkspaceViewInfoElement;
+
+declare global {
+	interface HTMLElementTagNameMap {
+		'umb-document-blueprint-workspace-view-info': UmbDocumentBlueprintWorkspaceViewInfoElement;
+	}
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/types.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/types.ts
index edbd441e7dce..d0a8a76a0e6a 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/types.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/types.ts
@@ -12,6 +12,7 @@ export type * from './entity.js';
 
 export interface UmbDocumentTypeDetailModel extends UmbContentTypeDetailModel {
 	entityType: UmbDocumentTypeEntityType;
+	allowedInLibrary: boolean;
 	allowedTemplates: Array<{ id: string }>;
 	defaultTemplate: { id: string } | null;
 	cleanup: UmbDocumentTypeCleanupModel;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/workspace/document-type/document-type-workspace.context.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/workspace/document-type/document-type-workspace.context.ts
index 1ff079a09df5..b1c5d3b5329e 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/workspace/document-type/document-type-workspace.context.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/workspace/document-type/document-type-workspace.context.ts
@@ -32,6 +32,7 @@ export class UmbDocumentTypeWorkspaceContext
 	implements UmbContentTypeWorkspaceContext<DetailModelType>, UmbRoutableWorkspaceContext
 {
 	// Document type specific:
+	readonly allowedInLibrary;
 	readonly allowedTemplateIds;
 	readonly defaultTemplate;
 	readonly cleanup;
@@ -47,10 +48,15 @@ export class UmbDocumentTypeWorkspaceContext
 		});
 
 		// Document type specific:
+		this.allowedInLibrary = this.structure.ownerContentTypeObservablePart((data) => data?.allowedInLibrary);
 		this.allowedTemplateIds = this.structure.ownerContentTypeObservablePart((data) => data?.allowedTemplates);
 		this.defaultTemplate = this.structure.ownerContentTypeObservablePart((data) => data?.defaultTemplate);
 		this.cleanup = this.structure.ownerContentTypeObservablePart((data) => data?.cleanup);
 
+		this.#setupRoutes();
+	}
+
+	#setupRoutes() {
 		this.routes.setRoutes([
 			{
 				path: UMB_CREATE_DOCUMENT_TYPE_WORKSPACE_PATH_PATTERN.toString(),
@@ -92,6 +98,10 @@ export class UmbDocumentTypeWorkspaceContext
 		this.structure.updateOwnerContentType({ allowedAtRoot });
 	}
 
+	setAllowedInLibrary(allowedInLibrary: boolean) {
+		this.structure.updateOwnerContentType({ allowedInLibrary });
+	}
+
 	setVariesByCulture(variesByCulture: boolean) {
 		this.structure.updateOwnerContentType({ variesByCulture });
 	}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/workspace/document-type/views/structure/document-type-workspace-view-structure.element.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/workspace/document-type/views/structure/document-type-workspace-view-structure.element.ts
index 814b5f5988df..7870053f203c 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/workspace/document-type/views/structure/document-type-workspace-view-structure.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/document-types/workspace/document-type/views/structure/document-type-workspace-view-structure.element.ts
@@ -1,6 +1,6 @@
 import type { UmbInputDocumentTypeElement } from '../../../../components/input-document-type/input-document-type.element.js';
 import { UMB_DOCUMENT_TYPE_WORKSPACE_CONTEXT } from '../../document-type-workspace.context-token.js';
-import { css, html, customElement, state } from '@umbraco-cms/backoffice/external/lit';
+import { css, html, customElement, state, when } from '@umbraco-cms/backoffice/external/lit';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import type {
@@ -17,12 +17,18 @@ export class UmbDocumentTypeWorkspaceViewStructureElement extends UmbLitElement
 	@state()
 	private _allowedAtRoot?: boolean;
 
+	@state()
+	private _allowedInLibrary?: boolean;
+
 	@state()
 	private _allowedContentTypeUniques?: Array<string>;
 
 	@state()
 	private _collection?: string | null;
 
+	@state()
+	private _isElementType = false;
+
 	constructor() {
 		super();
 
@@ -41,6 +47,12 @@ export class UmbDocumentTypeWorkspaceViewStructureElement extends UmbLitElement
 			'_allowedAtRootObserver',
 		);
 
+		this.observe(
+			this.#workspaceContext.allowedInLibrary,
+			(allowedInLibrary) => (this._allowedInLibrary = allowedInLibrary),
+			'_allowedInLibraryObserver',
+		);
+
 		this.observe(
 			this.#workspaceContext.allowedContentTypes,
 			(allowedContentTypes) => {
@@ -60,6 +72,12 @@ export class UmbDocumentTypeWorkspaceViewStructureElement extends UmbLitElement
 			},
 			'_collectionObserver',
 		);
+
+		this.observe(
+			this.#workspaceContext.isElement,
+			(isElement) => (this._isElementType = isElement ?? false),
+			'_isElementTypeObserver',
+		);
 	}
 
 	override render() {
@@ -76,6 +94,22 @@ export class UmbDocumentTypeWorkspaceViewStructureElement extends UmbLitElement
 							}}></uui-toggle>
 					</div>
 				</umb-property-layout>
+				${when(
+					this._isElementType,
+					() => html`
+						<umb-property-layout alias="library" label=${this.localize.term('contentTypeEditor_allowInLibraryHeading')}>
+							<div slot="description">${this.localize.term('contentTypeEditor_allowInLibraryDescription')}</div>
+							<div slot="editor">
+								<uui-toggle
+									label=${this.localize.term('contentTypeEditor_allowInLibraryHeading')}
+									?checked=${this._allowedInLibrary}
+									@change=${(e: CustomEvent) => {
+										this.#workspaceContext?.setAllowedInLibrary((e.target as UUIToggleElement).checked);
+									}}></uui-toggle>
+							</div>
+						</umb-property-layout>
+					`,
+				)}
 				<umb-property-layout alias="ChildNodeType" label=${this.localize.term('contentTypeEditor_childNodesHeading')}>
 					<div slot="description">${this.localize.term('contentTypeEditor_childNodesDescription')}</div>
 					<div slot="editor">
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/audit-log/info-app/document-history-workspace-info-app.element.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/audit-log/info-app/document-history-workspace-info-app.element.ts
index 59b0ec7f163a..882ca8071010 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/audit-log/info-app/document-history-workspace-info-app.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/audit-log/info-app/document-history-workspace-info-app.element.ts
@@ -1,11 +1,10 @@
 import { UmbDocumentAuditLogRepository } from '../repository/index.js';
 import { UMB_DOCUMENT_WORKSPACE_CONTEXT } from '../../workspace/constants.js';
 import type { UmbDocumentAuditLogModel } from '../types.js';
-import { TimeOptions } from '../../utils.js';
 import { getDocumentHistoryTagStyleAndText } from './utils.js';
 import { css, customElement, html, nothing, repeat, state, when } from '@umbraco-cms/backoffice/external/lit';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import { UmbPaginationManager } from '@umbraco-cms/backoffice/utils';
+import { UmbPaginationManager, UMB_DATE_TIME_FORMAT_OPTIONS } from '@umbraco-cms/backoffice/utils';
 import { UmbRequestReloadStructureForEntityEvent } from '@umbraco-cms/backoffice/entity-action';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
 import { UmbUserItemRepository } from '@umbraco-cms/backoffice/user';
@@ -138,7 +137,7 @@ export class UmbDocumentHistoryWorkspaceInfoAppElement extends UmbLitElement {
 						return html`
 							<umb-history-item
 								.name=${user?.name ?? 'Unknown'}
-								.detail=${this.localize.date(item.timestamp, TimeOptions)}>
+								.detail=${this.localize.date(item.timestamp, UMB_DATE_TIME_FORMAT_OPTIONS)}>
 								<umb-user-avatar
 									slot="avatar"
 									.name=${user?.name}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/audit-log/repository/document-audit-log.repository.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/audit-log/repository/document-audit-log.repository.ts
index 1fe0acb83f1a..fe03ff035c79 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/audit-log/repository/document-audit-log.repository.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/audit-log/repository/document-audit-log.repository.ts
@@ -2,7 +2,11 @@ import type { UmbDocumentAuditLogModel } from '../types.js';
 import type { UmbDocumentAuditLogType } from '../utils/index.js';
 import { getDocumentHistoryTagStyleAndText } from '../info-app/utils.js';
 import { UmbDocumentAuditLogServerDataSource } from './document-audit-log.server.data-source.js';
-import type { UmbAuditLogRepository, UmbAuditLogRequestArgs, UmbAuditLogTagData } from '@umbraco-cms/backoffice/audit-log';
+import type {
+	UmbAuditLogRepository,
+	UmbAuditLogRequestArgs,
+	UmbAuditLogTagData,
+} from '@umbraco-cms/backoffice/audit-log';
 import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
 import { UmbRepositoryBase } from '@umbraco-cms/backoffice/repository';
 
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/publishing/workspace-context/document-publishing.workspace-context.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/publishing/workspace-context/document-publishing.workspace-context.ts
index 9ff52f03a4d0..194a59291c2f 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/publishing/workspace-context/document-publishing.workspace-context.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/publishing/workspace-context/document-publishing.workspace-context.ts
@@ -42,6 +42,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase implem
 	#eventContext?: typeof UMB_ACTION_EVENT_CONTEXT.TYPE;
 	#publishingRepository = new UmbDocumentPublishingRepository(this);
 	#publishedDocumentData?: UmbDocumentDetailModel;
+	#loadingPublishedData = false;
 	#currentUnique?: UmbEntityUnique;
 	#notificationContext?: typeof UMB_NOTIFICATION_CONTEXT.TYPE;
 	readonly #localize = new UmbLocalizationController(this);
@@ -495,7 +496,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase implem
 				this.#currentUnique = unique;
 
 				if (isNew === false && unique) {
-					this.#loadAndProcessLastPublished();
+					this.#loadAndProcessLastPublished().catch(() => undefined);
 				}
 			},
 			'uniqueObserver',
@@ -503,13 +504,26 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase implem
 
 		this.observe(
 			this.#documentWorkspaceContext.persistedData,
-			() => this.#processPendingChanges(),
+			() => {
+				// The unique/isNew observer fires before document data is loaded,
+				// so #loadAndProcessLastPublished may return early (no variants yet).
+				// When persistedData arrives and published data hasn't been loaded,
+				// trigger the load now that variant data is available.
+				if (!this.#publishedDocumentData && this.#hasPublishedVariant()) {
+					this.#loadAndProcessLastPublished().catch(() => undefined);
+				} else {
+					this.#processPendingChanges();
+				}
+			},
 			'umbPersistedDataObserver',
 		);
 	}
 
 	#hasPublishedVariant() {
-		const variants = this.#documentWorkspaceContext?.getVariants();
+		// Use persisted data (falls back to current) because this may be called
+		// from the persistedData observer before setCurrent has run.
+		const variants = this.#documentWorkspaceContext?.getPersistedData()?.variants
+			?? this.#documentWorkspaceContext?.getVariants();
 		return (
 			variants?.some(
 				(variant) =>
@@ -532,9 +546,18 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase implem
 		const hasPublishedVariant = this.#hasPublishedVariant();
 		if (!hasPublishedVariant) return;
 
-		const { data } = await this.#publishingRepository.published(unique);
-		this.#publishedDocumentData = data;
-		this.#processPendingChanges();
+		// Prevent concurrent loads (e.g. save-and-publish calls #clear then reload,
+		// which can trigger this from both the persistedData observer and explicitly).
+		if (this.#loadingPublishedData) return;
+		this.#loadingPublishedData = true;
+
+		try {
+			const { data } = await this.#publishingRepository.published(unique);
+			this.#publishedDocumentData = data;
+			this.#processPendingChanges();
+		} finally {
+			this.#loadingPublishedData = false;
+		}
 	}
 
 	#processPendingChanges() {
@@ -549,6 +572,7 @@ export class UmbDocumentPublishingWorkspaceContext extends UmbContextBase implem
 
 	#clear() {
 		this.#publishedDocumentData = undefined;
+		this.#loadingPublishedData = false;
 		this.publishedPendingChanges.clear();
 	}
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/rollback/modal/rollback-modal.element.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/rollback/modal/rollback-modal.element.ts
index 41d8c530876f..3cf3cb3d6d28 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/rollback/modal/rollback-modal.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/rollback/modal/rollback-modal.element.ts
@@ -9,7 +9,7 @@ import { UmbModalBaseElement } from '@umbraco-cms/backoffice/modal';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
 import { UmbUserItemRepository } from '@umbraco-cms/backoffice/user';
 import { UMB_PROPERTY_DATASET_CONTEXT } from '@umbraco-cms/backoffice/property';
-import type { UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 import { UMB_APP_LANGUAGE_CONTEXT, UmbLanguageItemRepository } from '@umbraco-cms/backoffice/language';
 import { UMB_ENTITY_CONTEXT } from '@umbraco-cms/backoffice/entity';
 import { UmbVariantId } from '@umbraco-cms/backoffice/variant';
@@ -51,7 +51,7 @@ export class UmbRollbackModalElement extends UmbModalBaseElement<UmbRollbackModa
 	private _isInvariant = true;
 
 	@state()
-	private _availableVariants: Option[] = [];
+	private _availableVariants: UUISelectOption[] = [];
 
 	@state()
 	private _diffs: Array<{ alias: string; diff: UmbDiffChange[] }> = [];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/tree/tree-item/document-tree-item.element.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/tree/tree-item/document-tree-item.element.ts
index 958ceef2ae11..d4210c80efce 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/tree/tree-item/document-tree-item.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/tree/tree-item/document-tree-item.element.ts
@@ -23,7 +23,7 @@ export class UmbDocumentTreeItemElement extends UmbTreeItemElementBase<
 				this.requestUpdate('_forceShowExpand', oldValue);
 			});
 			this.observe(this.#api.icon, (icon) => (this.#icon = icon || ''));
-			this.observe(this.#api.flags, (flags) => (this._flags = flags || ''));
+			this.observe(this.#api.flags, (flags) => (this._flags = flags || []));
 			// Observe noAccess from context and update base class property (_noAccess).
 			// This enables access restriction behavior (click prevention) and styling from the base class.
 			this.observe(this.#api.noAccess, (noAccess) => (this._noAccess = noAccess));
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/user-permissions/document-property-value/input-document-property-value-user-permission/input-document-property-value-user-permission.element.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/user-permissions/document-property-value/input-document-property-value-user-permission/input-document-property-value-user-permission.element.ts
index 10dcdabcdf55..b65797c50297 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/user-permissions/document-property-value/input-document-property-value-user-permission/input-document-property-value-user-permission.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/user-permissions/document-property-value/input-document-property-value-user-permission/input-document-property-value-user-permission.element.ts
@@ -15,7 +15,7 @@ import {
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UMB_MODAL_MANAGER_CONTEXT } from '@umbraco-cms/backoffice/modal';
 import { umbExtensionsRegistry } from '@umbraco-cms/backoffice/extension-registry';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import {
 	UMB_ENTITY_USER_PERMISSION_MODAL,
 	type ManifestEntityUserPermission,
@@ -27,7 +27,10 @@ import {
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 
 @customElement('umb-input-document-property-value-user-permission')
-export class UmbInputDocumentPropertyValueUserPermissionElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbInputDocumentPropertyValueUserPermissionElement extends UUIFormControlWithBasicsMixin(
+	UmbLitElement,
+	'',
+) {
 	#permissions: Array<UmbDocumentPropertyValueUserPermissionModel> = [];
 	public get permissions(): Array<UmbDocumentPropertyValueUserPermissionModel> {
 		return this.#permissions;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/user-permissions/document/input-document-granular-user-permission/input-document-granular-user-permission.element.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/user-permissions/document/input-document-granular-user-permission/input-document-granular-user-permission.element.ts
index 376c005c7e40..1affb1892050 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/user-permissions/document/input-document-granular-user-permission/input-document-granular-user-permission.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/user-permissions/document/input-document-granular-user-permission/input-document-granular-user-permission.element.ts
@@ -9,14 +9,14 @@ import { UMB_MODAL_MANAGER_CONTEXT } from '@umbraco-cms/backoffice/modal';
 import type { UmbDeselectedEvent } from '@umbraco-cms/backoffice/event';
 import { UmbChangeEvent, UmbSelectedEvent } from '@umbraco-cms/backoffice/event';
 import { umbExtensionsRegistry } from '@umbraco-cms/backoffice/extension-registry';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import {
 	UMB_ENTITY_USER_PERMISSION_MODAL,
 	type ManifestEntityUserPermission,
 } from '@umbraco-cms/backoffice/user-permission';
 
 @customElement('umb-input-document-granular-user-permission')
-export class UmbInputDocumentGranularUserPermissionElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbInputDocumentGranularUserPermissionElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	#permissions: Array<UmbDocumentUserPermissionModel> = [];
 	public get permissions(): Array<UmbDocumentUserPermissionModel> {
 		return this.#permissions;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/utils.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/utils.ts
index 1c937e0b5c4f..37fb8e4986fe 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/utils.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/utils.ts
@@ -61,12 +61,3 @@ function compareName(a: VariantType, b: VariantType) {
 export function sortVariants(a: VariantType, b: VariantType) {
 	return compareDefault(a, b) || compareMandatory(a, b) || compareState(a, b) || compareName(a, b);
 }
-
-export const TimeOptions: Intl.DateTimeFormatOptions = {
-	year: 'numeric',
-	month: 'long',
-	day: 'numeric',
-	hour: 'numeric',
-	minute: 'numeric',
-	second: 'numeric',
-};
diff --git a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/workspace/views/info/document-workspace-view-info.element.ts b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/workspace/views/info/document-workspace-view-info.element.ts
index 12e77046e035..a9527631e10b 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/documents/documents/workspace/views/info/document-workspace-view-info.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/documents/documents/workspace/views/info/document-workspace-view-info.element.ts
@@ -1,20 +1,20 @@
 import { UMB_DOCUMENT_PROPERTY_DATASET_CONTEXT, UMB_DOCUMENT_WORKSPACE_CONTEXT } from '../../../constants.js';
 import type { UmbDocumentVariantModel } from '../../../types.js';
 import { UMB_DOCUMENT_PUBLISHING_WORKSPACE_CONTEXT } from '../../../publishing/index.js';
-import { TimeOptions } from '../../../utils.js';
 import { css, customElement, html, ifDefined, nothing, state } from '@umbraco-cms/backoffice/external/lit';
 import { DocumentVariantStateModel } from '@umbraco-cms/backoffice/external/backend-api';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbModalRouteRegistrationController } from '@umbraco-cms/backoffice/router';
 import { umbOpenModal } from '@umbraco-cms/backoffice/modal';
-import { UMB_WORKSPACE_MODAL } from '@umbraco-cms/backoffice/workspace';
-import { UMB_TEMPLATE_PICKER_MODAL, UmbTemplateItemRepository } from '@umbraco-cms/backoffice/template';
-import type { UmbDocumentTypeDetailModel } from '@umbraco-cms/backoffice/document-type';
-import type { UmbModalRouteBuilder } from '@umbraco-cms/backoffice/router';
+import { UmbTemplateItemRepository, UMB_TEMPLATE_PICKER_MODAL } from '@umbraco-cms/backoffice/template';
 import { createExtensionApiByAlias } from '@umbraco-cms/backoffice/extension-registry';
+import { UMB_DATE_TIME_FORMAT_OPTIONS } from '@umbraco-cms/backoffice/utils';
+import { UMB_IS_TRASHED_ENTITY_CONTEXT } from '@umbraco-cms/backoffice/recycle-bin';
 import { UMB_SECTION_USER_PERMISSION_CONDITION_ALIAS } from '@umbraco-cms/backoffice/section';
 import { UMB_SETTINGS_SECTION_ALIAS } from '@umbraco-cms/backoffice/settings';
-import { UMB_IS_TRASHED_ENTITY_CONTEXT } from '@umbraco-cms/backoffice/recycle-bin';
+import { UMB_WORKSPACE_MODAL } from '@umbraco-cms/backoffice/workspace';
+import type { UmbDocumentTypeDetailModel } from '@umbraco-cms/backoffice/document-type';
+import type { UmbModalRouteBuilder } from '@umbraco-cms/backoffice/router';
 
 @customElement('umb-document-workspace-view-info')
 export class UmbDocumentWorkspaceViewInfoElement extends UmbLitElement {
@@ -302,7 +302,7 @@ export class UmbDocumentWorkspaceViewInfoElement extends UmbLitElement {
 			<div class="general-item">
 				<strong><umb-localize .key=${labelKey}>${labelText}</umb-localize></strong>
 				<span>
-					<umb-localize-date .date=${date} .options=${TimeOptions}></umb-localize-date>
+					<umb-localize-date .date=${date} .options=${UMB_DATE_TIME_FORMAT_OPTIONS}></umb-localize-date>
 				</span>
 			</div>
 		`;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/collection/views/column-layouts/element-table-column-name.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/collection/views/column-layouts/element-table-column-name.element.ts
new file mode 100644
index 000000000000..828aff4aba21
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/collection/views/column-layouts/element-table-column-name.element.ts
@@ -0,0 +1,59 @@
+import { UmbElementItemDataResolver } from '../../../item/data-resolver/element-item-data-resolver.js';
+import type { UmbElementItemModel } from '../../../types.js';
+import { css, customElement, html, nothing, property, state } from '@umbraco-cms/backoffice/external/lit';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import type { UmbTableColumn, UmbTableColumnLayoutElement, UmbTableItem } from '@umbraco-cms/backoffice/components';
+
+type UmbEditableElementItemModel = { item: UmbElementItemModel; editPath: string };
+
+@customElement('umb-element-table-column-name')
+export class UmbElementTableColumnNameElement extends UmbLitElement implements UmbTableColumnLayoutElement {
+	#resolver = new UmbElementItemDataResolver(this);
+
+	@state()
+	private _name = '';
+
+	column!: UmbTableColumn;
+	item!: UmbTableItem;
+
+	@property({ attribute: false })
+	public set value(value: UmbEditableElementItemModel) {
+		this.#value = value;
+
+		if (value.item) {
+			this.#resolver.setData(value.item);
+		}
+	}
+	public get value(): UmbEditableElementItemModel {
+		return this.#value;
+	}
+	#value!: UmbEditableElementItemModel;
+
+	constructor() {
+		super();
+		this.#resolver.observe(this.#resolver.name, (name) => (this._name = name || ''));
+	}
+
+	override render() {
+		if (!this.value) return nothing;
+		if (!this.value.editPath) return nothing;
+		if (!this._name) return nothing;
+		return html`<uui-button compact href=${this.value.editPath} label=${this._name}></uui-button>`;
+	}
+
+	static override styles = [
+		css`
+			uui-button {
+				text-align: left;
+			}
+		`,
+	];
+}
+
+export default UmbElementTableColumnNameElement;
+
+declare global {
+	interface HTMLElementTagNameMap {
+		'umb-element-table-column-name': UmbElementTableColumnNameElement;
+	}
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/collection/views/column-layouts/element-table-column-state.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/collection/views/column-layouts/element-table-column-state.element.ts
new file mode 100644
index 000000000000..3072cbd4e45c
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/collection/views/column-layouts/element-table-column-state.element.ts
@@ -0,0 +1,64 @@
+import { UmbElementItemDataResolver } from '../../../item/data-resolver/element-item-data-resolver.js';
+import type { UmbElementItemModel } from '../../../types.js';
+import { customElement, html, property, state } from '@umbraco-cms/backoffice/external/lit';
+import { fromCamelCase } from '@umbraco-cms/backoffice/utils';
+import { DocumentVariantStateModel } from '@umbraco-cms/backoffice/external/backend-api';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import type { UmbTableColumn, UmbTableColumnLayoutElement, UmbTableItem } from '@umbraco-cms/backoffice/components';
+import type { UUIInterfaceColor } from '@umbraco-cms/backoffice/external/uui';
+
+@customElement('umb-element-table-column-state')
+export class UmbElementTableColumnStateElement extends UmbLitElement implements UmbTableColumnLayoutElement {
+	#resolver = new UmbElementItemDataResolver(this);
+
+	@state()
+	private _state = '';
+
+	column!: UmbTableColumn;
+	item!: UmbTableItem;
+
+	@property({ attribute: false })
+	public set value(value: UmbElementItemModel) {
+		this.#value = value;
+		if (value) {
+			this.#resolver.setData(value);
+		}
+	}
+	public get value(): UmbElementItemModel {
+		return this.#value;
+	}
+	#value!: UmbElementItemModel;
+
+	constructor() {
+		super();
+		this.#resolver.observe(this.#resolver.state, (state) => (this._state = state || ''));
+	}
+
+	#getStateTagConfig(): { color: UUIInterfaceColor; label: string } {
+		switch (this._state) {
+			case DocumentVariantStateModel.PUBLISHED:
+				return { color: 'positive', label: this.localize.term('content_published') };
+			case DocumentVariantStateModel.PUBLISHED_PENDING_CHANGES:
+				return { color: 'warning', label: this.localize.term('content_publishedPendingChanges') };
+			case DocumentVariantStateModel.DRAFT:
+				return { color: 'default', label: this.localize.term('content_unpublished') };
+			case DocumentVariantStateModel.NOT_CREATED:
+				return { color: 'danger', label: this.localize.term('content_notCreated') };
+			default:
+				return { color: 'danger', label: fromCamelCase(this._state) };
+		}
+	}
+
+	override render() {
+		const tagConfig = this.#getStateTagConfig();
+		return html`<uui-tag color=${tagConfig.color} look="secondary">${tagConfig.label}</uui-tag>`;
+	}
+}
+
+export default UmbElementTableColumnStateElement;
+
+declare global {
+	interface HTMLElementTagNameMap {
+		'umb-element-table-column-state': UmbElementTableColumnStateElement;
+	}
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/collection/views/element-table-collection-view.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/collection/views/element-table-collection-view.element.ts
index 6dd216e5fc39..b36fce479b23 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/collection/views/element-table-collection-view.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/collection/views/element-table-collection-view.element.ts
@@ -1,12 +1,12 @@
-import type { UmbElementTreeItemModel } from '../../tree/types.js';
 import { UMB_EDIT_ELEMENT_FOLDER_WORKSPACE_PATH_PATTERN } from '../../folder/workspace/constants.js';
 import { UMB_EDIT_ELEMENT_WORKSPACE_PATH_PATTERN } from '../../paths.js';
-import { css, customElement, html, state } from '@umbraco-cms/backoffice/external/lit';
+import { UMB_ELEMENT_ENTITY_TYPE, UMB_ELEMENT_FOLDER_ENTITY_TYPE } from '../../entity.js';
+import type { UmbElementItemModel } from '../../types.js';
+import type { UmbElementTreeItemModel } from '../../tree/types.js';
+import { customElement, html, nothing, state } from '@umbraco-cms/backoffice/external/lit';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
 import { UMB_COLLECTION_CONTEXT } from '@umbraco-cms/backoffice/collection';
 import type { UmbDefaultCollectionContext } from '@umbraco-cms/backoffice/collection';
-import type { UmbModalRouteBuilder } from '@umbraco-cms/backoffice/router';
 import type {
 	UmbTableColumn,
 	UmbTableConfig,
@@ -16,8 +16,11 @@ import type {
 	UmbTableSelectedEvent,
 } from '@umbraco-cms/backoffice/components';
 
-@customElement('umb-element-tree-item-table-collection-view')
-export class UmbElementTreeItemTableCollectionViewElement extends UmbLitElement {
+import './column-layouts/element-table-column-name.element.js';
+import './column-layouts/element-table-column-state.element.js';
+
+@customElement('umb-element-table-collection-view')
+export class UmbElementTableCollectionViewElement extends UmbLitElement {
 	@state()
 	private _items?: Array<UmbElementTreeItemModel>;
 
@@ -29,15 +32,11 @@ export class UmbElementTreeItemTableCollectionViewElement extends UmbLitElement
 
 	#collectionContext?: UmbDefaultCollectionContext<any>;
 
-	#routeBuilder?: UmbModalRouteBuilder;
-
 	#tableConfig: UmbTableConfig = { allowSelection: true };
 
 	#tableColumns: Array<UmbTableColumn> = [
-		{
-			name: this.localize.term('general_name'),
-			alias: 'name',
-		},
+		{ name: this.localize.term('general_name'), alias: 'name' },
+		{ name: this.localize.term('content_publishStatus'), alias: 'state' },
 		{ name: '', alias: 'entityActions', align: 'right' },
 	];
 
@@ -67,54 +66,47 @@ export class UmbElementTreeItemTableCollectionViewElement extends UmbLitElement
 			this.#collectionContext.selection.selection,
 			(selection) => {
 				if (selection) {
-					this._selection = selection as string[];
+					this._selection = selection;
 				}
 			},
 			'_observeSelection',
 		);
-
-		this.observe(
-			this.#collectionContext.workspacePathBuilder,
-			(routeBuilder) => {
-				this.#routeBuilder = routeBuilder;
-				this.#createTableItems();
-			},
-			'_observeWorkspacePathBuilder',
-		);
 	}
 
 	#createTableItems() {
 		if (!this._items) return;
-		const routeBuilder = this.#routeBuilder;
-		if (!routeBuilder) return;
 
 		this._tableItems = this._items.map((item) => {
-			const modalEditPath =
-				routeBuilder({ entityType: item.entityType }) +
-				UMB_EDIT_ELEMENT_WORKSPACE_PATH_PATTERN.generateLocal({ unique: item.unique });
-
-			const inlineEditPath = UMB_EDIT_ELEMENT_FOLDER_WORKSPACE_PATH_PATTERN.generateAbsolute({
-				unique: item.unique,
-			});
+			if (!item.unique) throw new Error('Item id is missing.');
+
+			const editPath = item.isFolder
+				? UMB_EDIT_ELEMENT_FOLDER_WORKSPACE_PATH_PATTERN.generateAbsolute({ unique: item.unique })
+				: UMB_EDIT_ELEMENT_WORKSPACE_PATH_PATTERN.generateAbsolute({ unique: item.unique });
+
+			const data = [
+				{
+					columnAlias: 'name',
+					value: html`<umb-element-table-column-name
+						.value=${{ item: item as UmbElementItemModel, editPath }}></umb-element-table-column-name>`,
+				},
+				{
+					columnAlias: 'state',
+					value: !item.isFolder
+						? html`<umb-element-table-column-state
+								.value=${item as UmbElementItemModel}></umb-element-table-column-state>`
+						: nothing,
+				},
+				{
+					columnAlias: 'entityActions',
+					value: html`<umb-entity-actions-table-column-view .value=${item}></umb-entity-actions-table-column-view>`,
+				},
+			];
 
 			return {
 				id: item.unique,
 				icon: item.isFolder && !item.icon ? 'icon-folder' : item.icon,
-				data: [
-					{
-						columnAlias: 'name',
-						value: html`
-							<uui-button
-								compact
-								href=${item.isFolder ? inlineEditPath : modalEditPath}
-								label=${item.name}></uui-button>
-						`,
-					},
-					{
-						columnAlias: 'entityActions',
-						value: html`<umb-entity-actions-table-column-view .value=${item}></umb-entity-actions-table-column-view>`,
-					},
-				],
+				entityType: item.isFolder ? UMB_ELEMENT_FOLDER_ENTITY_TYPE : UMB_ELEMENT_ENTITY_TYPE,
+				data,
 			};
 		});
 	}
@@ -145,22 +137,12 @@ export class UmbElementTreeItemTableCollectionViewElement extends UmbLitElement
 			</umb-table>
 		`;
 	}
-
-	static override styles = [
-		UmbTextStyles,
-		css`
-			:host {
-				display: flex;
-				flex-direction: column;
-			}
-		`,
-	];
 }
 
-export { UmbElementTreeItemTableCollectionViewElement as element };
+export { UmbElementTableCollectionViewElement as element };
 
 declare global {
 	interface HTMLElementTagNameMap {
-		'umb-element-tree-item-table-collection-view': UmbElementTreeItemTableCollectionViewElement;
+		'umb-element-table-collection-view': UmbElementTableCollectionViewElement;
 	}
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/constants.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/constants.ts
index 5ce3861b38b9..cd5868df2a80 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/constants.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/constants.ts
@@ -1,9 +1,11 @@
+export * from './collection/constants.js';
 export * from './entity-actions/constants.js';
 export * from './entity-bulk-actions/constants.js';
 export * from './folder/constants.js';
 export * from './item/constants.js';
 export * from './modals/constants.js';
 export * from './recycle-bin/constants.js';
+export * from './reference/constants.js';
 export * from './repository/constants.js';
 export * from './rollback/constants.js';
 export * from './tree/constants.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/entity-actions/create/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/entity-actions/create/manifests.ts
index 1073eef1dc87..d7b2be039620 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/entity-actions/create/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/entity-actions/create/manifests.ts
@@ -50,7 +50,7 @@ const elementCreateOptionAction: ManifestEntityCreateOptionAction = {
 const folderCreateOptionAction: ManifestEntityCreateOptionActionFolderKind = {
 	type: 'entityCreateOptionAction',
 	kind: 'folder',
-	alias: 'Umb.EntityCreateOptionAction.Element.Folder',
+	alias: 'Umb.EntityCreateOptionAction.ElementFolder',
 	name: 'Element Folder Entity Create Option Action',
 	forEntityTypes: [UMB_ELEMENT_ROOT_ENTITY_TYPE, UMB_ELEMENT_FOLDER_ENTITY_TYPE],
 	meta: {
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/entity-sign/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/entity-sign/manifests.ts
new file mode 100644
index 000000000000..9ec12f3c04ba
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/entity-sign/manifests.ts
@@ -0,0 +1,28 @@
+import { UMB_ELEMENT_ENTITY_TYPE } from '../entity.js';
+
+export const manifests: Array<UmbExtensionManifest> = [
+	{
+		type: 'entitySign',
+		kind: 'icon',
+		alias: 'Umb.EntitySign.Element.HasPendingChanges',
+		name: 'Has Pending Changes Element Entity Sign',
+		forEntityTypes: [UMB_ELEMENT_ENTITY_TYPE],
+		forEntityFlags: ['Umb.PendingChanges'],
+		meta: { iconName: 'icon-edit', label: '#content_unpublishedChanges' },
+	},
+	{
+		type: 'entitySign',
+		kind: 'icon',
+		alias: 'Umb.EntitySign.Element.HasScheduledPublish',
+		name: 'Element Has Scheduled Publish Entity Sign',
+		forEntityTypes: [UMB_ELEMENT_ENTITY_TYPE],
+		forEntityFlags: ['Umb.ScheduledForPublish'],
+		overwrites: 'Umb.EntitySign.Element.HasPendingChanges',
+		weight: 500,
+		meta: {
+			iconName: 'icon-time',
+			label: '#content_scheduledPublishing',
+			iconColorAlias: 'green',
+		},
+	},
+];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/data-resolver/element-folder-item-data-resolver.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/data-resolver/element-folder-item-data-resolver.ts
new file mode 100644
index 000000000000..d8f932613f0c
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/data-resolver/element-folder-item-data-resolver.ts
@@ -0,0 +1,48 @@
+import type { UmbElementFolderItemModel } from '../repository/item/types.js';
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import { UmbObjectState } from '@umbraco-cms/backoffice/observable-api';
+import type { UmbItemDataResolver } from '@umbraco-cms/backoffice/entity-item';
+
+/**
+ * A controller for resolving data for an element folder item
+ * @exports
+ * @class UmbElementFolderItemDataResolver
+ * @augments {UmbControllerBase}
+ */
+export class UmbElementFolderItemDataResolver extends UmbControllerBase implements UmbItemDataResolver {
+	#data = new UmbObjectState<UmbElementFolderItemModel | undefined>(undefined);
+
+	public readonly entityType = this.#data.asObservablePart((x) => x?.entityType);
+	public readonly unique = this.#data.asObservablePart((x) => x?.unique);
+	public readonly name = this.#data.asObservablePart((x) => x?.name);
+	public readonly icon = this.#data.asObservablePart((x) => x?.icon);
+
+	constructor(host: UmbControllerHost) {
+		super(host);
+	}
+
+	getData(): UmbElementFolderItemModel | undefined {
+		return this.#data.getValue();
+	}
+
+	setData(data: UmbElementFolderItemModel | undefined) {
+		this.#data.setValue(data);
+	}
+
+	async getEntityType(): Promise<string | undefined> {
+		return await this.observe(this.entityType).asPromise();
+	}
+
+	async getUnique(): Promise<string | undefined> {
+		return await this.observe(this.unique).asPromise();
+	}
+
+	async getName(): Promise<string | undefined> {
+		return await this.observe(this.name).asPromise();
+	}
+
+	async getIcon(): Promise<string | undefined> {
+		return await this.observe(this.icon).asPromise();
+	}
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/manifests.ts
index d6a3d53abea7..e0409587b4ec 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/manifests.ts
@@ -3,6 +3,7 @@ import { UMB_ELEMENT_FOLDER_REPOSITORY_ALIAS } from '../repository/constants.js'
 import {
 	UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
 	UMB_USER_PERMISSION_ELEMENT_DELETE,
+	UMB_USER_PERMISSION_ELEMENT_UPDATE,
 } from '../../user-permissions/constants.js';
 import { manifests as moveManifests } from './move/manifests.js';
 import {
@@ -13,12 +14,12 @@ import {
 const folderDelete: UmbExtensionManifest = {
 	type: 'entityAction',
 	kind: 'folderDelete',
-	alias: 'Umb.EntityAction.Element.Folder.Delete',
+	alias: 'Umb.EntityAction.ElementFolder.Delete',
 	name: 'Delete Element Folder Entity Action',
 	forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
 	meta: {
 		icon: 'icon-trash-empty',
-		folderRepositoryAlias: UMB_ELEMENT_FOLDER_REPOSITORY_ALIAS, // TODO: [LK] This needs to call the recycle-bin repository instead.
+		folderRepositoryAlias: UMB_ELEMENT_FOLDER_REPOSITORY_ALIAS,
 	},
 	conditions: [
 		{
@@ -32,13 +33,19 @@ const folderDelete: UmbExtensionManifest = {
 const folderUpdate: UmbExtensionManifest = {
 	type: 'entityAction',
 	kind: 'folderUpdate',
-	alias: 'Umb.EntityAction.Element.Folder.Rename',
+	alias: 'Umb.EntityAction.ElementFolder.Rename',
 	name: 'Rename Element Folder Entity Action',
 	forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
 	meta: {
 		folderRepositoryAlias: UMB_ELEMENT_FOLDER_REPOSITORY_ALIAS,
 	},
-	conditions: [{ alias: UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS }],
+	conditions: [
+		{
+			alias: UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
+			allOf: [UMB_USER_PERMISSION_ELEMENT_UPDATE],
+		},
+		{ alias: UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS },
+	],
 };
 
 export const manifests: Array<UmbExtensionManifest> = [folderDelete, folderUpdate, ...moveManifests];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/move/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/move/manifests.ts
index 138ba7a89357..fa533448dc44 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/move/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/move/manifests.ts
@@ -12,7 +12,7 @@ export const manifests: Array<UmbExtensionManifest> = [
 	{
 		type: 'entityAction',
 		kind: 'moveTo',
-		alias: 'Umb.EntityAction.Element.Folder.MoveTo',
+		alias: 'Umb.EntityAction.ElementFolder.MoveTo',
 		name: 'Move Element Folder Entity Action',
 		forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
 		meta: {
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/move/repository/constants.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/move/repository/constants.ts
index 024aa31f452b..3a7eafa9088c 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/move/repository/constants.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/entity-actions/move/repository/constants.ts
@@ -1 +1 @@
-export const UMB_MOVE_ELEMENT_FOLDER_REPOSITORY_ALIAS = 'Umb.Repository.Element.Folder.Move';
+export const UMB_MOVE_ELEMENT_FOLDER_REPOSITORY_ALIAS = 'Umb.Repository.ElementFolder.Move';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/index.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/index.ts
index 585e860a395d..cf358f365587 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/index.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/index.ts
@@ -1,2 +1,3 @@
+export * from './data-resolver/element-folder-item-data-resolver.js';
 export * from './entity-actions/index.js';
 export * from './repository/index.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/repository/constants.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/repository/constants.ts
index 9e5ea033b2b9..c79076ab54ea 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/repository/constants.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/repository/constants.ts
@@ -1,5 +1,5 @@
 export * from './item/constants.js';
 
-export const UMB_ELEMENT_FOLDER_REPOSITORY_ALIAS = 'Umb.Repository.Element.Folder';
-export const UMB_ELEMENT_FOLDER_STORE_ALIAS = 'Umb.Store.Element.Folder';
+export const UMB_ELEMENT_FOLDER_REPOSITORY_ALIAS = 'Umb.Repository.ElementFolder';
+export const UMB_ELEMENT_FOLDER_STORE_ALIAS = 'Umb.Store.ElementFolder';
 export { UMB_ELEMENT_FOLDER_STORE_CONTEXT } from './element-folder.store.context-token.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/repository/element-folder.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/repository/element-folder.server.data-source.ts
index 7821432563f0..59ddb38ac9d4 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/repository/element-folder.server.data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/repository/element-folder.server.data-source.ts
@@ -135,7 +135,7 @@ export class UmbElementFolderServerDataSource implements UmbDetailDataSource<Umb
 		if (!unique) throw new Error('Unique is missing');
 		return tryExecute(
 			this.#host,
-			ElementService.deleteElementFolderById({
+			ElementService.deleteRecycleBinElementFolderById({
 				path: { id: unique },
 			}),
 		);
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/tree/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/tree/manifests.ts
index 0b0317c0222c..96e0c173be34 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/tree/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/tree/manifests.ts
@@ -4,7 +4,7 @@ import type { ManifestTreeItem } from '@umbraco-cms/backoffice/tree';
 const treeItem: ManifestTreeItem = {
 	type: 'treeItem',
 	kind: 'default',
-	alias: 'Umb.TreeItem.Element.Folder',
+	alias: 'Umb.TreeItem.ElementFolder',
 	name: 'Element Folder Tree Item',
 	api: () => import('./element-folder-tree-item.context.js'),
 	forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/constants.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/constants.ts
index db7d5e6a2519..4bc5ffe95726 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/constants.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/constants.ts
@@ -1,4 +1,4 @@
-export const UMB_ELEMENT_FOLDER_WORKSPACE_ALIAS = 'Umb.Workspace.Element.Folder';
+export const UMB_ELEMENT_FOLDER_WORKSPACE_ALIAS = 'Umb.Workspace.ElementFolder';
 
 export * from './paths.js';
 export { UMB_ELEMENT_FOLDER_WORKSPACE_CONTEXT } from './element-folder.workspace.context-token.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/element-folder-menu-structure.context.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/element-folder-menu-structure.context.ts
new file mode 100644
index 000000000000..1b54d97df91d
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/element-folder-menu-structure.context.ts
@@ -0,0 +1,28 @@
+import { UMB_ELEMENT_TREE_REPOSITORY_ALIAS } from '../../tree/constants.js';
+import { UmbMenuTreeStructureWorkspaceContextBase } from '@umbraco-cms/backoffice/menu';
+import type { UmbStructureItemModel } from '@umbraco-cms/backoffice/menu';
+import { UMB_WORKSPACE_EDIT_PATH_PATTERN } from '@umbraco-cms/backoffice/workspace';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+
+export class UmbElementFolderMenuStructureContext extends UmbMenuTreeStructureWorkspaceContextBase {
+	constructor(host: UmbControllerHost) {
+		super(host, { treeRepositoryAlias: UMB_ELEMENT_TREE_REPOSITORY_ALIAS });
+	}
+
+	override getItemHref(structureItem: UmbStructureItemModel): string | undefined {
+		const sectionName = this._sectionContext?.getPathname();
+		if (!sectionName) return undefined;
+
+		if (!structureItem.unique) {
+			return `section/${sectionName}`;
+		}
+
+		return UMB_WORKSPACE_EDIT_PATH_PATTERN.generateAbsolute({
+			sectionName,
+			entityType: structureItem.entityType,
+			unique: structureItem.unique,
+		});
+	}
+}
+
+export default UmbElementFolderMenuStructureContext;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/element-folder-workspace.context.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/element-folder-workspace.context.ts
index 3e2d753b6200..3c8033628ad8 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/element-folder-workspace.context.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/element-folder-workspace.context.ts
@@ -41,6 +41,18 @@ export class UmbElementFolderWorkspaceContext
 
 	#onTrashStateChange(isTrashed?: boolean) {
 		this.#isTrashedContext.setIsTrashed(isTrashed ?? false);
+
+		const guardUnique = 'UMB_PREVENT_TRASHED_FOLDER_RENAME';
+
+		if (isTrashed) {
+			this.nameWriteGuard.addRule({
+				unique: guardUnique,
+				permitted: false,
+				message: 'Cannot rename folders in the recycle bin.',
+			});
+		} else {
+			this.nameWriteGuard.removeRule(guardUnique);
+		}
 	}
 }
 
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/manifests.ts
index eff7ffd43ac7..ffe670a7e16a 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/folder/workspace/manifests.ts
@@ -1,4 +1,5 @@
 import { UMB_ELEMENT_FOLDER_ENTITY_TYPE } from '../../entity.js';
+import { UMB_ELEMENT_MENU_ITEM_ALIAS } from '../../menu/constants.js';
 import { UMB_ELEMENT_ROOT_WORKSPACE_ALIAS } from '../../workspace/element-root/constants.js';
 import {
 	UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
@@ -7,8 +8,13 @@ import {
 import { UMB_ELEMENT_COLLECTION_ALIAS } from '../../collection/constants.js';
 import { UMB_ELEMENT_FOLDER_WORKSPACE_ALIAS } from './constants.js';
 import { UMB_WORKSPACE_CONDITION_ALIAS, UmbSubmitWorkspaceAction } from '@umbraco-cms/backoffice/workspace';
-import type { ManifestWorkspaceAction, ManifestWorkspaceRoutableKind } from '@umbraco-cms/backoffice/workspace';
+import type {
+	ManifestWorkspaceAction,
+	ManifestWorkspaceFooterApp,
+	ManifestWorkspaceRoutableKind,
+} from '@umbraco-cms/backoffice/workspace';
 import type { ManifestWorkspaceViewCollectionKind } from '@umbraco-cms/backoffice/collection';
+import type { ManifestWorkspaceContextMenuStructureKind } from '@umbraco-cms/backoffice/menu';
 import { UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS } from '@umbraco-cms/backoffice/recycle-bin';
 
 const workspace: ManifestWorkspaceRoutableKind = {
@@ -47,7 +53,7 @@ const workspaceView: ManifestWorkspaceViewCollectionKind = {
 const workspaceAction: ManifestWorkspaceAction = {
 	type: 'workspaceAction',
 	kind: 'default',
-	alias: 'Umb.WorkspaceAction.Element.Folder.Submit',
+	alias: 'Umb.WorkspaceAction.ElementFolder.Submit',
 	name: 'Submit Element Folder Workspace Action',
 	api: UmbSubmitWorkspaceAction,
 	meta: {
@@ -70,4 +76,40 @@ const workspaceAction: ManifestWorkspaceAction = {
 	],
 };
 
-export const manifests: Array<UmbExtensionManifest> = [workspace, workspaceView, workspaceAction];
+const menuStructure: ManifestWorkspaceContextMenuStructureKind = {
+	type: 'workspaceContext',
+	kind: 'menuStructure',
+	alias: 'Umb.Context.ElementFolder.Menu.Structure',
+	name: 'Element Folder Menu Structure Workspace Context',
+	api: () => import('./element-folder-menu-structure.context.js'),
+	meta: {
+		menuItemAlias: UMB_ELEMENT_MENU_ITEM_ALIAS,
+	},
+	conditions: [
+		{
+			alias: UMB_WORKSPACE_CONDITION_ALIAS,
+			match: UMB_ELEMENT_FOLDER_WORKSPACE_ALIAS,
+		},
+	],
+};
+
+const workspaceFooterApp: ManifestWorkspaceFooterApp = {
+	type: 'workspaceFooterApp',
+	kind: 'menuBreadcrumb',
+	alias: 'Umb.WorkspaceFooterApp.ElementFolder.Breadcrumb',
+	name: 'Element Folder Breadcrumb Workspace Footer App',
+	conditions: [
+		{
+			alias: UMB_WORKSPACE_CONDITION_ALIAS,
+			match: UMB_ELEMENT_FOLDER_WORKSPACE_ALIAS,
+		},
+	],
+};
+
+export const manifests: Array<UmbExtensionManifest> = [
+	workspace,
+	workspaceView,
+	workspaceAction,
+	menuStructure,
+	workspaceFooterApp,
+];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/global-components/input-element.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/global-components/input-element.element.ts
index 5d95c0615b5b..2ca2c25ef6f7 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/global-components/input-element.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/global-components/input-element.element.ts
@@ -1,10 +1,10 @@
 import { UmbElementTreePickerDataSource } from '../picker-data-source/element-tree.picker-data-source.js';
-import { html, customElement, property } from '@umbraco-cms/backoffice/external/lit';
+import { html, customElement, property, ifDefined } from '@umbraco-cms/backoffice/external/lit';
 import { splitStringToArray } from '@umbraco-cms/backoffice/utils';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 import { UmbFormControlMixin } from '@umbraco-cms/backoffice/validation';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import type { UmbConfigCollectionModel } from '@umbraco-cms/backoffice/utils';
+import type { UmbTreeStartNode } from '@umbraco-cms/backoffice/tree';
 
 @customElement('umb-input-element')
 export class UmbInputElementElement extends UmbFormControlMixin<string | undefined, typeof UmbLitElement>(
@@ -13,18 +13,8 @@ export class UmbInputElementElement extends UmbFormControlMixin<string | undefin
 ) {
 	#dataSourceApi = new UmbElementTreePickerDataSource(this);
 
-	#dataSourceConfig: UmbConfigCollectionModel = [];
-
-	#folderOnly = false;
-
 	@property({ type: Boolean })
-	set folderOnly(value: boolean) {
-		this.#folderOnly = value;
-		this.#dataSourceConfig = [{ alias: 'folderOnly', value }];
-	}
-	get folderOnly(): boolean {
-		return this.#folderOnly;
-	}
+	folderOnly = false;
 
 	@property({ type: Number })
 	min = 0;
@@ -49,6 +39,9 @@ export class UmbInputElementElement extends UmbFormControlMixin<string | undefin
 		return this.#selection;
 	}
 
+	@property({ type: Object, attribute: false })
+	startNode?: UmbTreeStartNode;
+
 	@property({ type: String })
 	public override set value(selectionString: string | undefined) {
 		this.#selection = splitStringToArray(selectionString);
@@ -72,16 +65,20 @@ export class UmbInputElementElement extends UmbFormControlMixin<string | undefin
 	}
 
 	override render() {
+		const dataSourceConfig = [
+			{ alias: 'folderOnly', value: this.folderOnly },
+			{ alias: 'startNode', value: this.startNode },
+		];
 		return html`
 			<umb-input-entity-data
+				min-message=${ifDefined(this.minMessage)}
+				max-message=${ifDefined(this.maxMessage)}
+				.dataSourceConfig=${dataSourceConfig}
 				.dataSourceApi=${this.#dataSourceApi}
-				.dataSourceConfig=${this.#dataSourceConfig}
 				.value=${this.value}
 				.selection=${this.selection}
 				.min=${this.min}
-				.minMessage=${this.minMessage}
 				.max=${this.max}
-				.maxMessage=${this.maxMessage}
 				?readonly=${this.readonly}
 				@change=${this.#onChange}>
 			</umb-input-entity-data>
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/item/data-resolver/element-item-data-resolver.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/item/data-resolver/element-item-data-resolver.ts
index 48ab7ca5b46a..f24e866cc4e6 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/item/data-resolver/element-item-data-resolver.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/item/data-resolver/element-item-data-resolver.ts
@@ -1,3 +1,4 @@
+import type { UmbElementEntityType, UmbElementFolderEntityType } from '../../entity.js';
 import { UmbElementVariantState } from '../../types.js';
 import type { UmbElementItemModel } from '../types.js';
 import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
@@ -14,7 +15,9 @@ import {
 import { type UmbVariantContext, UMB_VARIANT_CONTEXT } from '@umbraco-cms/backoffice/variant';
 import type { UmbItemDataResolver } from '@umbraco-cms/backoffice/entity-item';
 
-type UmbElementItemDataResolverModel = Omit<UmbElementItemModel, 'parent' | 'hasChildren'>;
+type UmbElementItemDataResolverModel = Omit<UmbElementItemModel, 'parent' | 'hasChildren' | 'entityType'> & {
+	entityType: UmbElementEntityType | UmbElementFolderEntityType;
+};
 
 /**
  * @param variants
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/item/repository/element-item.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/item/repository/element-item.server.data-source.ts
index bac16ef6ca77..eecd345fb86f 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/item/repository/element-item.server.data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/item/repository/element-item.server.data-source.ts
@@ -53,7 +53,7 @@ const mapper = (item: ElementItemResponseModel): UmbElementItemModel => {
 				culture: variant.culture || null,
 				name: variant.name,
 				state: variant.state,
-				flags: [], //variant.flags,
+				flags: variant.flags,
 				// TODO: [v17] Implement dates when available in the API. [LK]
 				//createDate: new Date(variant.createDate),
 				//updateDate: new Date(variant.updateDate),
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/item/repository/types.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/item/repository/types.ts
index 44df6cbf6b7d..0ae464edc376 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/item/repository/types.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/item/repository/types.ts
@@ -24,5 +24,5 @@ export interface UmbElementItemVariantModel {
 	createDate?: Date;
 	updateDate?: Date;
 	state?: UmbElementVariantState | null;
-	flags: Array<UmbEntityFlag>;
+	flags?: Array<UmbEntityFlag>;
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/manifests.ts
index b5bc5d045091..7b693fdb6adb 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/manifests.ts
@@ -1,10 +1,12 @@
 import { manifests as auditLogManifests } from './audit-log/manifests.js';
 import { manifests as collectionManifests } from './collection/manifests.js';
 import { manifests as entityActionManifests } from './entity-actions/manifests.js';
+import { manifests as entitySignManifests } from './entity-sign/manifests.js';
 import { manifests as entityBulkActionManifests } from './entity-bulk-actions/manifests.js';
 import { manifests as folderManifests } from './folder/manifests.js';
 import { manifests as itemManifests } from './item/manifests.js';
 import { manifests as menuManifests } from './menu/manifests.js';
+import { manifests as modalManifests } from './modals/manifests.js';
 import { manifests as propertyEditorManifests } from './property-editor/manifests.js';
 import { manifests as publishingManifests } from './publishing/manifests.js';
 import { manifests as recycleBinManifests } from './recycle-bin/manifests.js';
@@ -23,9 +25,11 @@ export const manifests: Array<UmbExtensionManifest> = [
 	...collectionManifests,
 	...entityActionManifests,
 	...entityBulkActionManifests,
+	...entitySignManifests,
 	...folderManifests,
 	...itemManifests,
 	...menuManifests,
+	...modalManifests,
 	...propertyEditorManifests,
 	...publishingManifests,
 	...recycleBinManifests,
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/modals/constants.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/constants.ts
index 61872ae7606e..c9ec1a0d8f72 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/modals/constants.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/constants.ts
@@ -1 +1,3 @@
-export { UMB_ELEMENT_PICKER_MODAL } from './element-picker-modal.token.js';
+export { UMB_ELEMENT_PICKER_MODAL, UMB_ELEMENT_FOLDER_PICKER_MODAL } from './element-picker-modal.token.js';
+export { UMB_ELEMENT_SAVE_MODAL } from './save-modal/element-save-modal.token.js';
+export * from './save-modal/constants.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/modals/element-picker-modal.token.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/element-picker-modal.token.ts
index b104e5dbb5d4..ffe55d3c64e2 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/modals/element-picker-modal.token.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/element-picker-modal.token.ts
@@ -19,3 +19,17 @@ export const UMB_ELEMENT_PICKER_MODAL = new UmbModalToken<UmbElementPickerModalD
 		},
 	},
 );
+
+export const UMB_ELEMENT_FOLDER_PICKER_MODAL = new UmbModalToken<UmbTreePickerModalData, UmbTreePickerModalValue>(
+	UMB_TREE_PICKER_MODAL_ALIAS,
+	{
+		modal: {
+			type: 'sidebar',
+			size: 'small',
+		},
+		data: {
+			treeAlias: UMB_ELEMENT_TREE_ALIAS,
+			foldersOnly: true,
+		},
+	},
+);
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/modals/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/manifests.ts
new file mode 100644
index 000000000000..ceb3f5196883
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/manifests.ts
@@ -0,0 +1,3 @@
+import { manifest as saveModalManifest } from './save-modal/manifest.js';
+
+export const manifests: Array<UmbExtensionManifest> = [saveModalManifest];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/constants.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/constants.ts
new file mode 100644
index 000000000000..8019a804f225
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/constants.ts
@@ -0,0 +1 @@
+export const UMB_ELEMENT_SAVE_MODAL_ALIAS = 'Umb.Modal.ElementSave';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/element-save-modal.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/element-save-modal.element.ts
new file mode 100644
index 000000000000..fc7369f51645
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/element-save-modal.element.ts
@@ -0,0 +1,94 @@
+import type { UmbElementVariantOptionModel } from '../../types.js';
+import type { UmbElementSaveModalData, UmbElementSaveModalValue } from './element-save-modal.token.js';
+import { css, customElement, html, state } from '@umbraco-cms/backoffice/external/lit';
+import { umbFocus } from '@umbraco-cms/backoffice/lit-element';
+import { UmbModalBaseElement } from '@umbraco-cms/backoffice/modal';
+import { UmbSelectionManager } from '@umbraco-cms/backoffice/utils';
+import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
+
+import '../shared/element-variant-language-picker.element.js';
+
+@customElement('umb-element-save-modal')
+export class UmbElementSaveModalElement extends UmbModalBaseElement<UmbElementSaveModalData, UmbElementSaveModalValue> {
+	#selectionManager = new UmbSelectionManager<string>(this);
+
+	@state()
+	private _options: Array<UmbElementVariantOptionModel> = [];
+
+	#pickableFilter = (option: UmbElementVariantOptionModel) => {
+		if (!option.variant) {
+			// If no data is present, then it's not pickable.
+			return false;
+		}
+		return this.data?.pickableFilter ? this.data.pickableFilter(option) : true;
+	};
+
+	override firstUpdated() {
+		this.#configureSelectionManager();
+	}
+
+	async #configureSelectionManager() {
+		this.#selectionManager.setMultiple(true);
+		this.#selectionManager.setSelectable(true);
+
+		// Only display variants that are relevant to pick from, i.e. variants that are draft or published with pending changes:
+		this._options = this.data?.options ?? [];
+
+		let selected = this.value?.selection ?? [];
+
+		const validOptions = this._options.filter((o) => this.#pickableFilter!(o));
+
+		// Filter selection based on options:
+		selected = selected.filter((s) => validOptions.some((o) => o.unique === s));
+
+		this.#selectionManager.setSelection(selected);
+	}
+
+	#submit() {
+		this.value = { selection: this.#selectionManager.getSelection() };
+		this.modalContext?.submit();
+	}
+
+	#close() {
+		this.modalContext?.reject();
+	}
+
+	override render() {
+		return html`
+			<uui-dialog-layout headline=${this.localize.term('content_saveModalTitle')}>
+				<umb-element-variant-language-picker
+					.selectionManager=${this.#selectionManager}
+					.variantLanguageOptions=${this._options}
+					.pickableFilter=${this.#pickableFilter}></umb-element-variant-language-picker>
+				<div slot="actions">
+					<uui-button label=${this.localize.term('general_close')} @click=${this.#close}></uui-button>
+					<uui-button
+						label=${this.localize.term('buttons_save')}
+						look="primary"
+						color="positive"
+						@click=${this.#submit}
+						${umbFocus()}></uui-button>
+				</div>
+			</uui-dialog-layout>
+		`;
+	}
+
+	static override styles = [
+		UmbTextStyles,
+		css`
+			:host {
+				display: block;
+				width: 400px;
+				max-width: 90vw;
+			}
+		`,
+	];
+}
+
+export default UmbElementSaveModalElement;
+
+declare global {
+	interface HTMLElementTagNameMap {
+		'umb-element-save-modal': UmbElementSaveModalElement;
+	}
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/element-save-modal.token.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/element-save-modal.token.ts
new file mode 100644
index 000000000000..afa074cde4fd
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/element-save-modal.token.ts
@@ -0,0 +1,18 @@
+import type { UmbElementVariantPickerData, UmbElementVariantPickerValue } from '../types.js';
+import { UMB_ELEMENT_SAVE_MODAL_ALIAS } from './constants.js';
+import { UmbModalToken } from '@umbraco-cms/backoffice/modal';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface UmbElementSaveModalData extends UmbElementVariantPickerData {}
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface UmbElementSaveModalValue extends UmbElementVariantPickerValue {}
+
+export const UMB_ELEMENT_SAVE_MODAL = new UmbModalToken<UmbElementSaveModalData, UmbElementSaveModalValue>(
+	UMB_ELEMENT_SAVE_MODAL_ALIAS,
+	{
+		modal: {
+			type: 'dialog',
+		},
+	},
+);
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/manifest.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/manifest.ts
new file mode 100644
index 000000000000..413f64b3ebfd
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/modals/save-modal/manifest.ts
@@ -0,0 +1,9 @@
+import { UMB_ELEMENT_SAVE_MODAL_ALIAS } from './constants.js';
+import type { ManifestModal } from '@umbraco-cms/backoffice/modal';
+
+export const manifest: ManifestModal = {
+	type: 'modal',
+	alias: UMB_ELEMENT_SAVE_MODAL_ALIAS,
+	name: 'Element Save Modal',
+	element: () => import('./element-save-modal.element.js'),
+};
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/picker-data-source/element-tree.picker-data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/picker-data-source/element-tree.picker-data-source.ts
index e51d6541ea4c..d7c9dc0b4e38 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/picker-data-source/element-tree.picker-data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/picker-data-source/element-tree.picker-data-source.ts
@@ -1,37 +1,64 @@
 import { UmbElementFolderItemRepository } from '../folder/repository/item/element-folder-item.repository.js';
 import { UmbElementItemRepository } from '../item/repository/element-item.repository.js';
 import { UmbElementTreeRepository } from '../tree/element-tree.repository.js';
+import type { UmbElementTreeChildrenOfRequestArgs, UmbElementTreeRootItemsRequestArgs } from '../tree/types.js';
 import { getConfigValue } from '@umbraco-cms/backoffice/utils';
 import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UMB_PROPERTY_TYPE_BASED_PROPERTY_CONTEXT } from '@umbraco-cms/backoffice/content';
 import type { UmbPickerTreeDataSource } from '@umbraco-cms/backoffice/picker-data-source';
 import type {
 	UmbTreeAncestorsOfRequestArgs,
 	UmbTreeChildrenOfRequestArgs,
 	UmbTreeItemModel,
 	UmbTreeRootItemsRequestArgs,
+	UmbTreeStartNode,
 } from '@umbraco-cms/backoffice/tree';
 import type { UmbConfigCollectionModel } from '@umbraco-cms/backoffice/utils';
+import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
 
 export class UmbElementTreePickerDataSource extends UmbControllerBase implements UmbPickerTreeDataSource {
+	#dataType?: { unique: string };
 	#elementItem = new UmbElementItemRepository(this);
 	#folderItem = new UmbElementFolderItemRepository(this);
 	#folderOnly = false;
 	#tree = new UmbElementTreeRepository(this);
+	#startNode?: UmbTreeStartNode;
+
+	constructor(host: UmbControllerHost) {
+		super(host);
+
+		this.consumeContext(UMB_PROPERTY_TYPE_BASED_PROPERTY_CONTEXT, (context) => {
+			this.observe(context?.dataType, (dataType) => {
+				this.#dataType = dataType;
+			});
+		});
+	}
 
 	setConfig(config: UmbConfigCollectionModel | undefined) {
 		this.#folderOnly = Boolean(getConfigValue(config, 'folderOnly'));
+		this.#startNode = getConfigValue(config, 'startNode');
 	}
 
+	requestTreeStartNode = async () => this.#startNode ?? undefined;
+
 	requestTreeRoot = () => this.#tree.requestTreeRoot();
 
 	requestTreeRootItems = (args: UmbTreeRootItemsRequestArgs) => {
-		args.foldersOnly = this.#folderOnly;
-		return this.#tree.requestTreeRootItems(args);
+		const typedArgs: UmbElementTreeRootItemsRequestArgs = {
+			...args,
+			foldersOnly: this.#folderOnly,
+			dataType: this.#dataType,
+		};
+		return this.#tree.requestTreeRootItems(typedArgs);
 	};
 
 	requestTreeItemsOf = (args: UmbTreeChildrenOfRequestArgs) => {
-		args.foldersOnly = this.#folderOnly;
-		return this.#tree.requestTreeItemsOf(args);
+		const typedArgs: UmbElementTreeChildrenOfRequestArgs = {
+			...args,
+			foldersOnly: this.#folderOnly,
+			dataType: this.#dataType,
+		};
+		return this.#tree.requestTreeItemsOf(typedArgs);
 	};
 
 	requestTreeItemAncestors = (args: UmbTreeAncestorsOfRequestArgs) => this.#tree.requestTreeItemAncestors(args);
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/Umbraco.ElementPicker.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/Umbraco.ElementPicker.ts
index 886bf3171fdf..169d893bbe0b 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/Umbraco.ElementPicker.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/Umbraco.ElementPicker.ts
@@ -6,5 +6,16 @@ export const manifest: ManifestPropertyEditorSchema = {
 	alias: 'Umbraco.ElementPicker',
 	meta: {
 		defaultPropertyEditorUiAlias: 'Umb.PropertyEditorUi.ElementPicker',
+		settings: {
+			properties: [
+				{
+					alias: 'ignoreUserStartNodes',
+					label: 'Ignore user start nodes',
+					description: "Selecting this option allows a user to choose nodes that they normally don't have access to.",
+					propertyEditorUiAlias: 'Umb.PropertyEditorUi.Toggle',
+					weight: 120,
+				},
+			],
+		},
 	},
 };
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/element-picker-property-editor-ui.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/element-picker-property-editor-ui.element.ts
index f6bea52546d2..41f1c81d9073 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/element-picker-property-editor-ui.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/element-picker-property-editor-ui.element.ts
@@ -1,9 +1,11 @@
-import { customElement, html, property, state } from '@umbraco-cms/backoffice/external/lit';
+import { UMB_ELEMENT_FOLDER_ENTITY_TYPE } from '../../entity.js';
+import { customElement, html, property, state } from '@umbraco-cms/backoffice/external/lit';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
-import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbFormControlMixin, UMB_VALIDATION_EMPTY_LOCALIZATION_KEY } from '@umbraco-cms/backoffice/validation';
+import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import type { UmbNumberRangeValueType } from '@umbraco-cms/backoffice/models';
 import type { UmbPropertyEditorUiElement } from '@umbraco-cms/backoffice/property-editor';
+import type { UmbTreeStartNode } from '@umbraco-cms/backoffice/tree';
 
 @customElement('umb-element-picker-property-editor-ui')
 export class UmbElementPickerPropertyEditorUIElement
@@ -25,14 +27,24 @@ export class UmbElementPickerPropertyEditorUIElement
 	public set config(config: UmbPropertyEditorUiElement['config'] | undefined) {
 		if (!config) return;
 
+		this._folderOnly = Boolean(config.getValueByAlias('folderOnly'));
+
 		const minMax = config?.getValueByAlias<UmbNumberRangeValueType>('validationLimit');
 		this._min = minMax?.min ?? 0;
 		this._max = minMax?.max ?? Infinity;
 
 		this._minMessage = `${this.localize.term('validation_minCount')} ${this._min} ${this.localize.term('validation_items')}`;
 		this._maxMessage = `${this.localize.term('validation_maxCount')} ${this._max} ${this.localize.term('validation_itemsSelected')}`;
+
+		const startNodeId = config.getValueByAlias<Array<string>>('startNodeId') ?? [];
+		this._startNode = startNodeId.length
+			? { unique: startNodeId[0], entityType: UMB_ELEMENT_FOLDER_ENTITY_TYPE }
+			: undefined;
 	}
 
+	@state()
+	private _folderOnly = false;
+
 	@state()
 	private _min = 0;
 
@@ -45,6 +57,9 @@ export class UmbElementPickerPropertyEditorUIElement
 	@state()
 	private _maxMessage = '';
 
+	@state()
+	private _startNode?: UmbTreeStartNode;
+
 	override focus() {
 		return this.shadowRoot?.querySelector('umb-input-element')?.focus();
 	}
@@ -71,10 +86,12 @@ export class UmbElementPickerPropertyEditorUIElement
 		return html`
 			<umb-input-element
 				.selection=${this.value ?? []}
+				.startNode=${this._startNode}
 				.min=${this._min}
-				.min-message=${this._minMessage}
+				.minMessage=${this._minMessage}
 				.max=${this._max}
-				.max-message=${this._maxMessage}
+				.maxMessage=${this._maxMessage}
+				?folderOnly=${this._folderOnly}
 				?readonly=${this.readonly}
 				@change=${this.#onChange}>
 			</umb-input-element>
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/manifests.ts
index 7c608fda4dc5..ff8192de1175 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/property-editor/element-picker/manifests.ts
@@ -21,6 +21,17 @@ const propertyEditorUi: ManifestPropertyEditorUi = {
 					config: [{ alias: 'validationRange', value: { min: 0, max: Infinity } }],
 					weight: 100,
 				},
+				{
+					alias: 'startNodeId',
+					label: 'Start node',
+					description: '',
+					propertyEditorUiAlias: 'Umb.PropertyEditorUi.ElementPicker',
+					config: [
+						{ alias: 'folderOnly', value: true },
+						{ alias: 'validationLimit', value: { min: 0, max: 1 } },
+					],
+					weight: 110,
+				},
 			],
 		},
 	},
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/element-published-pending-changes.manager.test.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/element-published-pending-changes.manager.test.ts
new file mode 100644
index 000000000000..1286408bc797
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/element-published-pending-changes.manager.test.ts
@@ -0,0 +1,214 @@
+import { expect } from '@open-wc/testing';
+import { Observable } from '@umbraco-cms/backoffice/external/rxjs';
+import { customElement } from '@umbraco-cms/backoffice/external/lit';
+import { UmbControllerHostElementMixin } from '@umbraco-cms/backoffice/controller-api';
+import { UmbElementPublishedPendingChangesManager } from './element-published-pending-changes.manager.js';
+import { DocumentVariantStateModel } from '@umbraco-cms/backoffice/external/backend-api';
+import { type UmbElementDetailModel } from '../../types.js';
+import { UMB_ELEMENT_ENTITY_TYPE } from '../../entity.js';
+
+@customElement('test-my-controller-host')
+class UmbTestControllerHostElement extends UmbControllerHostElementMixin(HTMLElement) {}
+
+describe('UmbElementPublishedPendingChangesManager', () => {
+	let manager: UmbElementPublishedPendingChangesManager;
+
+	beforeEach(() => {
+		const hostElement = new UmbTestControllerHostElement();
+		manager = new UmbElementPublishedPendingChangesManager(hostElement);
+	});
+
+	describe('Public API', () => {
+		describe('properties', () => {
+			it('has a variantsWithChanges property', () => {
+				expect(manager).to.have.property('variantsWithChanges').to.be.an.instanceOf(Observable);
+			});
+		});
+
+		describe('methods', () => {
+			it('has a process method', () => {
+				expect(manager).to.have.property('process').that.is.a('function');
+			});
+
+			it('has a getVariantsWithChanges method', () => {
+				expect(manager).to.have.property('getVariantsWithChanges').that.is.a('function');
+			});
+		});
+	});
+
+	describe('process', () => {
+		beforeEach(() => {
+			const hostElement = new UmbTestControllerHostElement();
+			manager = new UmbElementPublishedPendingChangesManager(hostElement);
+		});
+
+		describe('invariant data', () => {
+			let persistedElement: UmbElementDetailModel;
+			let publishedElement: UmbElementDetailModel;
+			let elementBase: UmbElementDetailModel = {
+				entityType: UMB_ELEMENT_ENTITY_TYPE,
+				unique: '1',
+				documentType: {
+					unique: 'element-type-1',
+					icon: 'icon-element',
+					collection: null,
+				},
+				isTrashed: false,
+				flags: [],
+				variants: [
+					{
+						state: DocumentVariantStateModel.PUBLISHED,
+						publishDate: '2023-02-06T15:32:24.957009',
+						culture: null,
+						segment: null,
+						name: 'Element 1',
+						createDate: '2023-02-06T15:32:05.350038',
+						updateDate: '2023-02-06T15:32:24.957009',
+						scheduledPublishDate: null,
+						scheduledUnpublishDate: null,
+						flags: [],
+					},
+				],
+				values: [
+					{
+						editorAlias: 'Umbraco.TextBox',
+						alias: 'prop1',
+						culture: null,
+						segment: null,
+						value: '',
+					},
+				],
+			};
+
+			beforeEach(() => {
+				persistedElement = structuredClone(elementBase);
+				publishedElement = structuredClone(elementBase);
+			});
+
+			it('should set variantsWithChanges to an empty array if there are no pending changes', async () => {
+				await manager.process({ persistedData: persistedElement, publishedData: publishedElement });
+				expect(manager.getVariantsWithChanges()).to.be.an('array').that.is.empty;
+			});
+
+			it('should have variants with changes when value is updated', async () => {
+				persistedElement.values[0].value = 'value';
+				await manager.process({ persistedData: persistedElement, publishedData: publishedElement });
+				const variantsWithChanges = manager.getVariantsWithChanges();
+				expect(variantsWithChanges).to.have.lengthOf(1);
+				expect(variantsWithChanges[0].variantId.toString()).to.equal('invariant');
+			});
+
+			it('should have variants with changes when name of variant is updated', async () => {
+				persistedElement.variants[0].name = 'Element 1 Updated';
+				await manager.process({ persistedData: persistedElement, publishedData: publishedElement });
+				const variantsWithChanges = manager.getVariantsWithChanges();
+				expect(variantsWithChanges).to.have.lengthOf(1);
+				expect(variantsWithChanges[0].variantId.toString()).to.equal('invariant');
+			});
+		});
+
+		describe('variant data', () => {
+			let persistedElement: UmbElementDetailModel;
+			let publishedElement: UmbElementDetailModel;
+			let elementBase: UmbElementDetailModel = {
+				entityType: UMB_ELEMENT_ENTITY_TYPE,
+				unique: '1',
+				documentType: {
+					unique: 'element-type-1',
+					icon: 'icon-element',
+					collection: null,
+				},
+				isTrashed: false,
+				flags: [],
+				variants: [
+					{
+						state: DocumentVariantStateModel.PUBLISHED,
+						publishDate: '2023-02-06T15:32:24.957009',
+						culture: 'en-US',
+						segment: null,
+						name: 'Element 1 (en-US)',
+						createDate: '2023-02-06T15:32:05.350038',
+						updateDate: '2023-02-06T15:32:24.957009',
+						scheduledPublishDate: null,
+						scheduledUnpublishDate: null,
+						flags: [],
+					},
+					{
+						state: DocumentVariantStateModel.PUBLISHED,
+						publishDate: '2023-02-06T15:32:24.957009',
+						culture: 'da-DK',
+						segment: null,
+						name: 'Element 1 (da-DK)',
+						createDate: '2023-02-06T15:32:05.350038',
+						updateDate: '2023-02-06T15:32:24.957009',
+						scheduledPublishDate: null,
+						scheduledUnpublishDate: null,
+						flags: [],
+					},
+				],
+				values: [
+					{
+						editorAlias: 'Umbraco.TextBox',
+						alias: 'prop1',
+						culture: 'en-US',
+						segment: null,
+						value: '',
+					},
+					{
+						editorAlias: 'Umbraco.TextBox',
+						alias: 'prop1',
+						culture: 'da-DK',
+						segment: null,
+						value: '',
+					},
+				],
+			};
+
+			beforeEach(() => {
+				persistedElement = structuredClone(elementBase);
+				publishedElement = structuredClone(elementBase);
+			});
+
+			it('should not have variants with changes when there are no pending changes', async () => {
+				await manager.process({ persistedData: persistedElement, publishedData: publishedElement });
+				expect(manager.getVariantsWithChanges()).to.be.an('array').that.is.empty;
+			});
+
+			it('should have variants with changes when value is updated', async () => {
+				persistedElement.values[0].value = 'value (en-US)';
+				await manager.process({ persistedData: persistedElement, publishedData: publishedElement });
+				const variantsWithChanges = manager.getVariantsWithChanges();
+				expect(variantsWithChanges).to.have.lengthOf(1);
+				expect(variantsWithChanges[0].variantId.toString()).to.equal('en-US');
+			});
+
+			it('should have variants with changes when multiple values are updated', async () => {
+				persistedElement.values[0].value = 'value (en-US)';
+				persistedElement.values[1].value = 'value (da-DK)';
+				await manager.process({ persistedData: persistedElement, publishedData: publishedElement });
+				const variantsWithChanges = manager.getVariantsWithChanges();
+				expect(variantsWithChanges).to.have.lengthOf(2);
+				expect(variantsWithChanges[0].variantId.toString()).to.equal('en-US');
+				expect(variantsWithChanges[1].variantId.toString()).to.equal('da-DK');
+			});
+
+			it('should have variants with changes when name of variant is updated', async () => {
+				persistedElement.variants[0].name = 'Element 1 (en-US) Updated';
+				await manager.process({ persistedData: persistedElement, publishedData: publishedElement });
+				const variantsWithChanges = manager.getVariantsWithChanges();
+				expect(variantsWithChanges).to.have.lengthOf(1);
+				expect(variantsWithChanges[0].variantId.toString()).to.equal('en-US');
+			});
+
+			it('should have variants with changes when name of multiple variants are updated', async () => {
+				persistedElement.variants[0].name = 'Element 1 (en-US) Updated';
+				persistedElement.variants[1].name = 'Element 1 (da-DK) Updated';
+				await manager.process({ persistedData: persistedElement, publishedData: publishedElement });
+				const variantsWithChanges = manager.getVariantsWithChanges();
+				expect(variantsWithChanges).to.have.lengthOf(2);
+				expect(variantsWithChanges[0].variantId.toString()).to.equal('en-US');
+				expect(variantsWithChanges[1].variantId.toString()).to.equal('da-DK');
+			});
+		});
+	});
+});
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/element-published-pending-changes.manager.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/element-published-pending-changes.manager.ts
new file mode 100644
index 000000000000..d3d3d7ce15f7
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/element-published-pending-changes.manager.ts
@@ -0,0 +1,92 @@
+import type { UmbElementVariantModel } from '../../types.js';
+import type {
+	UmbElementPublishedPendingChangesManagerProcessArgs,
+	UmbPublishedElementVariantWithPendingChanges,
+} from './types.js';
+import { UmbVariantId } from '@umbraco-cms/backoffice/variant';
+import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { UmbMergeContentVariantDataController } from '@umbraco-cms/backoffice/content';
+import { jsonStringComparison, UmbArrayState } from '@umbraco-cms/backoffice/observable-api';
+
+/**
+ * Manages the pending changes for a published element.
+ * @exports
+ * @class UmbElementPublishedPendingChangesManager
+ * @augments {UmbControllerBase}
+ */
+export class UmbElementPublishedPendingChangesManager extends UmbControllerBase {
+	#variantsWithChanges = new UmbArrayState<UmbPublishedElementVariantWithPendingChanges>([], (x) =>
+		x.variantId.toString(),
+	);
+	public readonly variantsWithChanges = this.#variantsWithChanges.asObservable();
+
+	/**
+	 * Checks each variant if there are any pending changes to publish.
+	 * @param {UmbElementPublishedPendingChangesManagerProcessArgs} args - The arguments for the process.
+	 * @param {UmbElementDetailModel} args.persistedData - The persisted element data.
+	 * @param {UmbElementDetailModel} args.publishedData - The published element data.
+	 * @returns {Promise<void>}
+	 * @memberof UmbElementPublishedPendingChangesManager
+	 */
+	async process(args: UmbElementPublishedPendingChangesManagerProcessArgs): Promise<void> {
+		if (!args.persistedData) throw new Error('Persisted data is missing');
+		if (!args.publishedData) throw new Error('Published data is missing');
+		if (args.persistedData.unique !== args.publishedData.unique)
+			throw new Error('Persisted and published data does not have the same unique');
+
+		const variantIds = args.persistedData.variants?.map((x) => UmbVariantId.Create(x)) ?? [];
+
+		const pendingChangesPromises = variantIds.map(async (variantId) => {
+			const mergedData = await new UmbMergeContentVariantDataController(this).process(
+				args.publishedData,
+				args.persistedData,
+				[variantId],
+				[variantId],
+			);
+
+			const mergedDataClone = structuredClone(mergedData);
+			const publishedDataClone = structuredClone(args.publishedData);
+
+			// remove dates from the comparison
+			mergedDataClone.variants.forEach((variant) => this.#cleanVariantForComparison(variant));
+			publishedDataClone.variants.forEach((variant) => this.#cleanVariantForComparison(variant));
+
+			const hasChanges = jsonStringComparison(mergedDataClone, publishedDataClone) === false;
+
+			if (hasChanges) {
+				return { variantId };
+			} else {
+				return null;
+			}
+		});
+
+		const variantsWithPendingChanges = (await Promise.all(pendingChangesPromises)).filter((x) => x !== null);
+
+		this.#variantsWithChanges.setValue(variantsWithPendingChanges);
+	}
+
+	/**
+	 * Gets the variants with changes.
+	 * @returns {Array<UmbPublishedElementVariantWithPendingChanges>}
+	 * @memberof UmbElementPublishedPendingChangesManager
+	 */
+	getVariantsWithChanges(): Array<UmbPublishedElementVariantWithPendingChanges> {
+		return this.#variantsWithChanges.getValue();
+	}
+
+	#cleanVariantForComparison = (variant: UmbElementVariantModel) => {
+		// The server seems to have some date mismatches when quickly
+		// fetching an element after a save and comparing it to the published version.
+		// This is a temporary workaround to not include these dates in the comparison.
+		// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+		// @ts-expect-error
+		delete variant.updateDate;
+	};
+
+	/**
+	 * Clear all states/values.
+	 */
+	clear() {
+		this.#variantsWithChanges.setValue([]);
+	}
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/index.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/index.ts
new file mode 100644
index 000000000000..c0d7afad456e
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/index.ts
@@ -0,0 +1 @@
+export * from './element-published-pending-changes.manager.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/types.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/types.ts
new file mode 100644
index 000000000000..5362e2f287e0
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/pending-changes/types.ts
@@ -0,0 +1,11 @@
+import type { UmbElementDetailModel } from '../../types.js';
+import type { UmbVariantId } from '@umbraco-cms/backoffice/variant';
+
+export interface UmbElementPublishedPendingChangesManagerProcessArgs {
+	persistedData: UmbElementDetailModel;
+	publishedData: UmbElementDetailModel;
+}
+
+export interface UmbPublishedElementVariantWithPendingChanges {
+	variantId: UmbVariantId;
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/workspace-context/element-publishing.workspace-context.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/workspace-context/element-publishing.workspace-context.ts
index ab2132d1ace0..4a1317354a4e 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/workspace-context/element-publishing.workspace-context.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/publishing/workspace-context/element-publishing.workspace-context.ts
@@ -2,6 +2,7 @@ import { UMB_ELEMENT_WORKSPACE_CONTEXT } from '../../workspace/element-workspace
 import type { UmbElementDetailModel, UmbElementVariantOptionModel } from '../../types.js';
 import { UmbElementVariantState } from '../../types.js';
 import { UmbElementPublishingRepository } from '../repository/index.js';
+import { UmbElementPublishedPendingChangesManager } from '../pending-changes/index.js';
 import type { UmbElementVariantPublishModel } from '../types.js';
 import { UMB_ELEMENT_PUBLISH_MODAL } from '../publish/constants.js';
 import { UMB_ELEMENT_UNPUBLISH_MODAL } from '../unpublish/constants.js';
@@ -11,7 +12,9 @@ import { UMB_ELEMENT_WORKSPACE_ALIAS } from '../../workspace/constants.js';
 import { UMB_ELEMENT_PUBLISHING_WORKSPACE_CONTEXT } from './element-publishing.workspace-context.token.js';
 import { UMB_ELEMENT_PUBLISHING_SHORTCUT_UNIQUE } from './constants.js';
 import { firstValueFrom } from '@umbraco-cms/backoffice/external/rxjs';
+import { observeMultiple } from '@umbraco-cms/backoffice/observable-api';
 import { umbOpenModal } from '@umbraco-cms/backoffice/modal';
+import { DocumentVariantStateModel } from '@umbraco-cms/backoffice/external/backend-api';
 import { UmbContextBase } from '@umbraco-cms/backoffice/class-api';
 import { UmbLocalizationController } from '@umbraco-cms/backoffice/localization-api';
 import { UmbRequestReloadStructureForEntityEvent } from '@umbraco-cms/backoffice/entity-action';
@@ -19,13 +22,22 @@ import { UmbVariantId } from '@umbraco-cms/backoffice/variant';
 import { UMB_ACTION_EVENT_CONTEXT } from '@umbraco-cms/backoffice/action';
 import { UMB_NOTIFICATION_CONTEXT } from '@umbraco-cms/backoffice/notification';
 import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
+import type { UmbEntityUnique } from '@umbraco-cms/backoffice/entity';
 import type { UmbPublishableWorkspaceContext } from '@umbraco-cms/backoffice/workspace';
 
 export class UmbElementPublishingWorkspaceContext extends UmbContextBase implements UmbPublishableWorkspaceContext {
+	/**
+	 * Manages the pending changes for the published element.
+	 * @memberof UmbElementPublishingWorkspaceContext
+	 */
+	public readonly publishedPendingChanges = new UmbElementPublishedPendingChangesManager(this);
+
 	#init: Promise<unknown>;
 	#elementWorkspaceContext?: typeof UMB_ELEMENT_WORKSPACE_CONTEXT.TYPE;
 	#eventContext?: typeof UMB_ACTION_EVENT_CONTEXT.TYPE;
 	#publishingRepository = new UmbElementPublishingRepository(this);
+	#publishedElementData?: UmbElementDetailModel;
+	#currentUnique?: UmbEntityUnique;
 	#notificationContext?: typeof UMB_NOTIFICATION_CONTEXT.TYPE;
 	readonly #localize = new UmbLocalizationController(this);
 
@@ -48,6 +60,7 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase impleme
 					modifier: true,
 					action: () => this.saveAndPublish(),
 				});
+				this.#initPendingChanges();
 			})
 				.asPromise({ preventTimeout: true })
 				.catch(() => {
@@ -150,7 +163,10 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase impleme
 				data: { message: this.#localize.term('speechBubbles_editElementUnpublishedHeader') },
 			});
 
+			this.#clear();
+
 			await this.#elementWorkspaceContext?.reload();
+			await this.#loadAndProcessLastPublished();
 
 			const event = new UmbRequestReloadStructureForEntityEvent({ unique, entityType });
 			this.#eventContext?.dispatchEvent(event);
@@ -340,8 +356,15 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase impleme
 				data: { message: this.#localize.term('speechBubbles_editElementPublishedHeader') },
 			});
 
+			// Clear stale published data and pending changes state so the
+			// persistedData observer does not run a comparison against outdated
+			// data during reload, which would briefly show a false-positive
+			// "pending changes" state.
+			this.#clear();
+
 			// reload the element so all states are updated after the publish operation
 			await this.#elementWorkspaceContext.reload();
+			await this.#loadAndProcessLastPublished();
 
 			const event = new UmbRequestReloadStructureForEntityEvent({ unique, entityType });
 			this.#eventContext?.dispatchEvent(event);
@@ -400,6 +423,80 @@ export class UmbElementPublishingWorkspaceContext extends UmbContextBase impleme
 
 		return [...new Set(selected)];
 	}
+
+	async #initPendingChanges() {
+		if (!this.#elementWorkspaceContext) {
+			return;
+		}
+
+		this.observe(
+			observeMultiple([this.#elementWorkspaceContext.unique, this.#elementWorkspaceContext.isNew]),
+			([unique, isNew]) => {
+				// We have loaded in a new element, so we need to clear the states
+				if (unique !== this.#currentUnique) {
+					this.#clear();
+				}
+
+				this.#currentUnique = unique;
+
+				if (isNew === false && unique) {
+					this.#loadAndProcessLastPublished();
+				}
+			},
+			'uniqueObserver',
+		);
+
+		this.observe(
+			this.#elementWorkspaceContext.persistedData,
+			() => this.#processPendingChanges(),
+			'umbPersistedDataObserver',
+		);
+	}
+
+	#hasPublishedVariant() {
+		const variants = this.#elementWorkspaceContext?.getVariants();
+		return (
+			variants?.some(
+				(variant) =>
+					variant.state === DocumentVariantStateModel.PUBLISHED ||
+					variant.state === DocumentVariantStateModel.PUBLISHED_PENDING_CHANGES,
+			) ?? false
+		);
+	}
+
+	async #loadAndProcessLastPublished() {
+		if (!this.#elementWorkspaceContext) throw new Error('Element workspace context is missing');
+
+		// No need to check pending changes for new elements
+		if (this.#elementWorkspaceContext.getIsNew()) return;
+
+		const unique = this.#elementWorkspaceContext.getUnique();
+		if (!unique) throw new Error('Unique is missing');
+
+		// Only load the published data if the element is already published or has been published before
+		const hasPublishedVariant = this.#hasPublishedVariant();
+		if (!hasPublishedVariant) return;
+
+		// TODO: Implement once ElementService.getElementByIdPublished endpoint exists [LK]
+		// const { data } = await this.#publishingRepository.published(unique);
+		// this.#publishedElementData = data;
+		// this.#processPendingChanges();
+	}
+
+	#processPendingChanges() {
+		if (!this.#elementWorkspaceContext) throw new Error('Element workspace context is missing');
+
+		const persistedData = this.#elementWorkspaceContext.getPersistedData();
+		const publishedData = this.#publishedElementData;
+		if (!persistedData || !publishedData) return;
+
+		this.publishedPendingChanges.process({ persistedData, publishedData });
+	}
+
+	#clear() {
+		this.#publishedElementData = undefined;
+		this.publishedPendingChanges.clear();
+	}
 }
 
 export { UmbElementPublishingWorkspaceContext as api };
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/collection/action/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/collection/action/manifests.ts
index 5375907948a1..6cf77308687a 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/collection/action/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/collection/action/manifests.ts
@@ -1,18 +1,20 @@
 import { UMB_ELEMENT_RECYCLE_BIN_REPOSITORY_ALIAS } from '../../repository/constants.js';
 import { UMB_ELEMENT_RECYCLE_BIN_COLLECTION_ALIAS } from '../constants.js';
+import { UMB_ELEMENT_RECYCLE_BIN_ROOT_ENTITY_TYPE } from '../../constants.js';
 import {
 	UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
 	UMB_USER_PERMISSION_ELEMENT_DELETE,
 } from '../../../user-permissions/constants.js';
 import { UMB_COLLECTION_ALIAS_CONDITION } from '@umbraco-cms/backoffice/collection';
+import { UMB_ENTITY_TYPE_CONDITION_ALIAS } from '@umbraco-cms/backoffice/entity';
 import type { ManifestCollectionActionEmptyRecycleBinKind } from '@umbraco-cms/backoffice/recycle-bin';
 
 export const manifests: Array<ManifestCollectionActionEmptyRecycleBinKind> = [
 	{
 		type: 'collectionAction',
 		kind: 'emptyRecycleBin',
-		name: 'Element Collection Empty Recycle Bin Action',
 		alias: 'Umb.CollectionAction.Element.EmptyRecycleBin',
+		name: 'Element Collection Empty Recycle Bin Action',
 		meta: {
 			label: '#actions_emptyrecyclebin',
 			recycleBinRepositoryAlias: UMB_ELEMENT_RECYCLE_BIN_REPOSITORY_ALIAS,
@@ -22,6 +24,10 @@ export const manifests: Array<ManifestCollectionActionEmptyRecycleBinKind> = [
 				alias: UMB_COLLECTION_ALIAS_CONDITION,
 				match: UMB_ELEMENT_RECYCLE_BIN_COLLECTION_ALIAS,
 			},
+			{
+				alias: UMB_ENTITY_TYPE_CONDITION_ALIAS,
+				match: UMB_ELEMENT_RECYCLE_BIN_ROOT_ENTITY_TYPE,
+			},
 			{
 				alias: UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
 				allOf: [UMB_USER_PERMISSION_ELEMENT_DELETE],
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/entity-actions/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/entity-actions/manifests.ts
index 5b5d166fffbd..b78fd8fbadcc 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/entity-actions/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/entity-actions/manifests.ts
@@ -1,17 +1,21 @@
-import { UMB_ELEMENT_DETAIL_REPOSITORY_ALIAS } from '../../repository/detail/constants.js';
-import { UMB_ELEMENT_ENTITY_TYPE, UMB_ELEMENT_FOLDER_ENTITY_TYPE } from '../../entity.js';
-import { UMB_ELEMENT_FOLDER_REPOSITORY_ALIAS } from '../../folder/repository/constants.js';
-import { UMB_ELEMENT_ITEM_REPOSITORY_ALIAS } from '../../item/constants.js';
+import { UmbElementFolderItemDataResolver } from '../../folder/data-resolver/element-folder-item-data-resolver.js';
+import { UmbElementItemDataResolver } from '../../item/data-resolver/element-item-data-resolver.js';
+import {
+	UMB_ELEMENT_DETAIL_REPOSITORY_ALIAS,
+	UMB_ELEMENT_FOLDER_ITEM_REPOSITORY_ALIAS,
+	UMB_ELEMENT_FOLDER_PICKER_MODAL,
+	UMB_ELEMENT_FOLDER_REPOSITORY_ALIAS,
+	UMB_ELEMENT_ITEM_REPOSITORY_ALIAS,
+	UMB_ELEMENT_REFERENCE_REPOSITORY_ALIAS,
+	UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
+	UMB_USER_PERMISSION_ELEMENT_DELETE,
+} from '../../constants.js';
+import { UMB_ELEMENT_ENTITY_TYPE, UMB_ELEMENT_FOLDER_ENTITY_TYPE, UMB_ELEMENT_ROOT_ENTITY_TYPE } from '../../entity.js';
 import {
 	UMB_ELEMENT_FOLDER_RECYCLE_BIN_REPOSITORY_ALIAS,
 	UMB_ELEMENT_RECYCLE_BIN_REPOSITORY_ALIAS,
 	UMB_ELEMENT_RECYCLE_BIN_ROOT_ENTITY_TYPE,
 } from '../constants.js';
-import { UMB_ELEMENT_REFERENCE_REPOSITORY_ALIAS } from '../../reference/constants.js';
-import {
-	UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
-	UMB_USER_PERMISSION_ELEMENT_DELETE,
-} from '../../user-permissions/constants.js';
 import { UMB_ENTITY_HAS_CHILDREN_CONDITION_ALIAS } from '@umbraco-cms/backoffice/entity-action';
 import {
 	UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS,
@@ -26,6 +30,7 @@ const elementActions: Array<UmbExtensionManifest> = [
 		name: 'Trash Element Entity Action',
 		forEntityTypes: [UMB_ELEMENT_ENTITY_TYPE],
 		meta: {
+			itemDataResolver: UmbElementItemDataResolver,
 			itemRepositoryAlias: UMB_ELEMENT_ITEM_REPOSITORY_ALIAS,
 			recycleBinRepositoryAlias: UMB_ELEMENT_RECYCLE_BIN_REPOSITORY_ALIAS,
 			referenceRepositoryAlias: UMB_ELEMENT_REFERENCE_REPOSITORY_ALIAS,
@@ -61,31 +66,34 @@ const elementActions: Array<UmbExtensionManifest> = [
 			{ alias: UMB_ENTITY_IS_TRASHED_CONDITION_ALIAS },
 		],
 	},
-	// {
-	// 	type: 'entityAction',
-	// 	kind: 'restoreFromRecycleBin',
-	// 	alias: 'Umb.EntityAction.Element.RecycleBin.Restore',
-	// 	name: 'Restore Element From Recycle Bin Entity Action',
-	// 	forEntityTypes: [UMB_ELEMENT_ENTITY_TYPE],
-	// 	meta: {
-	// 		itemRepositoryAlias: UMB_ELEMENT_ITEM_REPOSITORY_ALIAS,
-	// 		itemDataResolver: UmbElementItemDataResolver,
-	// 		recycleBinRepositoryAlias: UMB_ELEMENT_RECYCLE_BIN_REPOSITORY_ALIAS,
-	// 		pickerModal: UMB_ELEMENT_PICKER_MODAL,
-	// 	},
-	// 	conditions: [
-	// 		{
-	// 			alias: UMB_ENTITY_IS_TRASHED_CONDITION_ALIAS,
-	// 		},
-	// 	],
-	// },
+	{
+		type: 'entityAction',
+		kind: 'restoreFromRecycleBin',
+		alias: 'Umb.EntityAction.Element.RecycleBin.Restore',
+		name: 'Restore Element From Recycle Bin Entity Action',
+		forEntityTypes: [UMB_ELEMENT_ENTITY_TYPE],
+		meta: {
+			destinationItemRepositoryAlias: UMB_ELEMENT_FOLDER_ITEM_REPOSITORY_ALIAS,
+			destinationRootEntityType: UMB_ELEMENT_ROOT_ENTITY_TYPE,
+			destinationItemDataResolver: UmbElementFolderItemDataResolver,
+			itemRepositoryAlias: UMB_ELEMENT_ITEM_REPOSITORY_ALIAS,
+			itemDataResolver: UmbElementItemDataResolver,
+			pickerModal: UMB_ELEMENT_FOLDER_PICKER_MODAL,
+			recycleBinRepositoryAlias: UMB_ELEMENT_RECYCLE_BIN_REPOSITORY_ALIAS,
+		},
+		conditions: [
+			{
+				alias: UMB_ENTITY_IS_TRASHED_CONDITION_ALIAS,
+			},
+		],
+	},
 ];
 
 const folderActions: Array<UmbExtensionManifest> = [
 	{
 		type: 'entityAction',
 		kind: 'trashFolder',
-		alias: 'Umb.EntityAction.Element.Folder.Trash',
+		alias: 'Umb.EntityAction.ElementFolder.Trash',
 		name: 'Trash Element Folder Entity Action',
 		forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
 		meta: {
@@ -100,6 +108,22 @@ const folderActions: Array<UmbExtensionManifest> = [
 			{ alias: UMB_ENTITY_IS_NOT_TRASHED_CONDITION_ALIAS },
 		],
 	},
+	{
+		type: 'entityAction',
+		kind: 'restoreFromRecycleBin',
+		alias: 'Umb.EntityAction.ElementFolder.RecycleBin.Restore',
+		name: 'Restore Element Folder From Recycle Bin Entity Action',
+		forEntityTypes: [UMB_ELEMENT_FOLDER_ENTITY_TYPE],
+		meta: {
+			destinationRootEntityType: UMB_ELEMENT_ROOT_ENTITY_TYPE,
+			destinationItemDataResolver: UmbElementFolderItemDataResolver,
+			itemRepositoryAlias: UMB_ELEMENT_FOLDER_ITEM_REPOSITORY_ALIAS,
+			itemDataResolver: UmbElementFolderItemDataResolver,
+			pickerModal: UMB_ELEMENT_FOLDER_PICKER_MODAL,
+			recycleBinRepositoryAlias: UMB_ELEMENT_FOLDER_RECYCLE_BIN_REPOSITORY_ALIAS,
+		},
+		conditions: [{ alias: UMB_ENTITY_IS_TRASHED_CONDITION_ALIAS }],
+	},
 ];
 
 const emptyRecycleBin: UmbExtensionManifest = {
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/constants.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/constants.ts
index 0fd00a1a62e6..809dcce3ca7d 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/constants.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/constants.ts
@@ -1,2 +1,2 @@
 export const UMB_ELEMENT_RECYCLE_BIN_REPOSITORY_ALIAS = 'Umb.Repository.Element.RecycleBin';
-export const UMB_ELEMENT_FOLDER_RECYCLE_BIN_REPOSITORY_ALIAS = 'Umb.Repository.Element.Folder.RecycleBin';
+export const UMB_ELEMENT_FOLDER_RECYCLE_BIN_REPOSITORY_ALIAS = 'Umb.Repository.ElementFolder.RecycleBin';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/element-folder-recycle-bin.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/element-folder-recycle-bin.server.data-source.ts
index 81441fe20ed4..694f58173259 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/element-folder-recycle-bin.server.data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/element-folder-recycle-bin.server.data-source.ts
@@ -22,14 +22,12 @@ export class UmbElementFolderRecycleBinServerDataSource implements UmbRecycleBin
 	restore(args: UmbRecycleBinRestoreRequestArgs) {
 		return tryExecute(
 			this.#host,
-			Promise.reject(`Recycle bin folder restore has not been implemented yet. (${args.unique})`),
-			// TODO: Uncomment this when backend endpoint is available. [LK:2026-01-06]
-			// ElementService.putRecycleBinElementFolderByIdRestore({
-			// 	path: { id: args.unique },
-			// 	body: {
-			// 		target: args.destination.unique ? { id: args.destination.unique } : null,
-			// 	},
-			// }),
+			ElementService.putRecycleBinElementFolderByIdRestore({
+				path: { id: args.unique },
+				body: {
+					target: args.destination.unique ? { id: args.destination.unique } : null,
+				},
+			}),
 		);
 	}
 
@@ -40,16 +38,13 @@ export class UmbElementFolderRecycleBinServerDataSource implements UmbRecycleBin
 	async getOriginalParent(args: UmbRecycleBinOriginalParentRequestArgs) {
 		const { data, error } = await tryExecute(
 			this.#host,
-			Promise.reject(`Recycle bin folder restore has not been implemented yet. (${args.unique})`),
-			// TODO: Uncomment this when backend endpoint is available. [LK:2026-01-06]
-			//ElementService.getRecycleBinElementFolderByIdOriginalParent({ path: { id: args.unique } }),
+			ElementService.getRecycleBinElementFolderByIdOriginalParent({ path: { id: args.unique } }),
 		);
 
 		// only check for undefined because data can be null if the parent is the root
 		if (data !== undefined) {
-			// TODO: Uncomment this when backend endpoint is available. [LK:2026-01-06]
-			// const mappedData = data ? { unique: data.id } : null;
-			// return { data: mappedData };
+			const mappedData = data ? { unique: data.id } : null;
+			return { data: mappedData };
 		}
 
 		return { error };
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/element-recycle-bin.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/element-recycle-bin.server.data-source.ts
index a5aef1214950..5212c86f1845 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/element-recycle-bin.server.data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/repository/element-recycle-bin.server.data-source.ts
@@ -22,14 +22,12 @@ export class UmbElementRecycleBinServerDataSource implements UmbRecycleBinDataSo
 	restore(args: UmbRecycleBinRestoreRequestArgs) {
 		return tryExecute(
 			this.#host,
-			Promise.reject(`Recycle bin restore has not been implemented yet. (${args.unique})`),
-			// TODO: Uncomment this when backend endpoint is available. [LK:2026-01-06]
-			// ElementService.putRecycleBinElementByIdRestore({
-			// 	path: { id: args.unique },
-			// 	body: {
-			// 		target: args.destination.unique ? { id: args.destination.unique } : null,
-			// 	},
-			// }),
+			ElementService.putRecycleBinElementByIdRestore({
+				path: { id: args.unique },
+				body: {
+					target: args.destination.unique ? { id: args.destination.unique } : null,
+				},
+			}),
 		);
 	}
 
@@ -40,16 +38,13 @@ export class UmbElementRecycleBinServerDataSource implements UmbRecycleBinDataSo
 	async getOriginalParent(args: UmbRecycleBinOriginalParentRequestArgs) {
 		const { data, error } = await tryExecute(
 			this.#host,
-			Promise.reject(`Recycle bin restore has not been implemented yet. (${args.unique})`),
-			// TODO: Uncomment this when backend endpoint is available. [LK:2026-01-06]
-			//ElementService.getRecycleBinElementByIdOriginalParent({ path: { id: args.unique } }),
+			ElementService.getRecycleBinElementByIdOriginalParent({ path: { id: args.unique } }),
 		);
 
 		// only check for undefined because data can be null if the parent is the root
 		if (data !== undefined) {
-			// TODO: Uncomment this when backend endpoint is available. [LK:2026-01-06]
-			// const mappedData = data ? { unique: data.id } : null;
-			// return { data: mappedData };
+			const mappedData = data ? { unique: data.id } : null;
+			return { data: mappedData };
 		}
 
 		return { error };
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/tree/element-recycle-bin-tree.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/tree/element-recycle-bin-tree.server.data-source.ts
index 9aa81785081d..2918c2450a60 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/tree/element-recycle-bin-tree.server.data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/recycle-bin/tree/element-recycle-bin-tree.server.data-source.ts
@@ -85,7 +85,7 @@ const mapper = (item: ElementRecycleBinItemResponseModel): UmbElementRecycleBinT
 				culture: variant.culture || null,
 				segment: null, // TODO: add segment to the backend API?
 				state: variant.state,
-				//flags: variant.flags ?? [],
+				flags: variant.flags,
 			};
 		}),
 		// TODO: this is not correct. We need to get it from the variants. This is a temp solution. [LK]
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/repository/detail/element-detail.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/repository/detail/element-detail.server.data-source.ts
index 6acbab4dd59a..76f4fc59769c 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/repository/detail/element-detail.server.data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/repository/detail/element-detail.server.data-source.ts
@@ -164,7 +164,7 @@ export class UmbElementServerDataSource implements UmbDetailDataSource<UmbElemen
 	async delete(unique: string) {
 		if (!unique) throw new Error('Unique is missing');
 
-		return tryExecute(this.#host, ElementService.deleteElementById({ path: { id: unique } }));
+		return tryExecute(this.#host, ElementService.deleteRecycleBinElementById({ path: { id: unique } }));
 	}
 
 	#createElementDetailModel(data: ElementResponseModel): UmbElementDetailModel {
@@ -191,12 +191,13 @@ export class UmbElementServerDataSource implements UmbDetailDataSource<UmbElemen
 					updateDate: variant.updateDate,
 					scheduledPublishDate: variant.scheduledPublishDate || null,
 					scheduledUnpublishDate: variant.scheduledUnpublishDate || null,
-					flags: [], //variant.flags,
+					flags: variant.flags,
 				};
 			}),
 			documentType: {
 				unique: data.documentType.id,
 				collection: null,
+				icon: data.documentType.icon,
 			},
 			isTrashed: data.isTrashed,
 			flags: data.flags,
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/rollback/modal/rollback-modal.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/rollback/modal/rollback-modal.element.ts
index 8869d32902b8..bed3516ed949 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/rollback/modal/rollback-modal.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/rollback/modal/rollback-modal.element.ts
@@ -15,7 +15,7 @@ import { UMB_APP_LANGUAGE_CONTEXT, UmbLanguageItemRepository } from '@umbraco-cm
 import { UMB_ENTITY_CONTEXT } from '@umbraco-cms/backoffice/entity';
 import { UMB_PROPERTY_DATASET_CONTEXT } from '@umbraco-cms/backoffice/property';
 import type { UmbDiffChange } from '@umbraco-cms/backoffice/utils';
-import type { UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 
 import '../../modals/shared/element-variant-language-picker.element.js';
 
@@ -54,7 +54,7 @@ export class UmbElementRollbackModalElement extends UmbModalBaseElement<
 	private _isInvariant = true;
 
 	@state()
-	private _availableVariants: Option[] = [];
+	private _availableVariants: UUISelectOption[] = [];
 
 	@state()
 	private _diffs: Array<{ alias: string; diff: UmbDiffChange[] }> = [];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree-item.context.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree-item.context.ts
index 795532c8d12e..584a9800efd4 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree-item.context.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree-item.context.ts
@@ -1,3 +1,4 @@
+import { UmbElementItemDataResolver } from '../item/data-resolver/element-item-data-resolver.js';
 import type { UmbElementTreeItemModel, UmbElementTreeRootModel } from './types.js';
 import { UmbDefaultTreeItemContext } from '@umbraco-cms/backoffice/tree';
 import { UmbIsTrashedEntityContext } from '@umbraco-cms/backoffice/recycle-bin';
@@ -9,6 +10,13 @@ export class UmbElementTreeItemContext extends UmbDefaultTreeItemContext<
 > {
 	// TODO: Provide this together with the EntityContext, ideally this takes part via a extension-type [NL]
 	#isTrashedContext = new UmbIsTrashedEntityContext(this);
+	#item = new UmbElementItemDataResolver(this);
+
+	readonly name = this.#item.name;
+	readonly icon = this.#item.icon;
+	readonly typeUnique = this.#item.typeUnique;
+	readonly isDraft = this.#item.isDraft;
+	readonly flags = this.#item.flags;
 
 	// TODO: Move to API
 	readonly isTrashed = this._treeItem.asObservablePart((item) => item?.isTrashed ?? false);
@@ -20,6 +28,11 @@ export class UmbElementTreeItemContext extends UmbDefaultTreeItemContext<
 			this.#isTrashedContext.setIsTrashed(isTrashed);
 		});
 	}
+
+	public override setTreeItem(treeItem: UmbElementTreeItemModel | undefined) {
+		super.setTreeItem(treeItem);
+		this.#item.setData(treeItem);
+	}
 }
 
 export { UmbElementTreeItemContext as api };
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree-item.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree-item.element.ts
new file mode 100644
index 000000000000..601f61f114f1
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree-item.element.ts
@@ -0,0 +1,74 @@
+import type { UmbElementTreeItemModel } from './types.js';
+import type { UmbElementTreeItemContext } from './element-tree-item.context.js';
+import { classMap, css, customElement, html, property, state } from '@umbraco-cms/backoffice/external/lit';
+import { UmbTreeItemElementBase } from '@umbraco-cms/backoffice/tree';
+
+@customElement('umb-element-tree-item')
+export class UmbElementTreeItemElement extends UmbTreeItemElementBase<
+	UmbElementTreeItemModel,
+	UmbElementTreeItemContext
+> {
+	#api: UmbElementTreeItemContext | undefined;
+
+	@property({ type: Object, attribute: false })
+	public override set api(value: UmbElementTreeItemContext | undefined) {
+		this.#api = value;
+
+		if (this.#api) {
+			this.observe(this.#api.name, (name) => (this._name = name || ''));
+			this.observe(this.#api.isDraft, (isDraft) => (this._isDraft = isDraft || false));
+			this.observe(this.#api.icon, (icon) => (this.#icon = icon || ''));
+			this.observe(this.#api.flags, (flags) => (this._flags = flags ?? []));
+		}
+
+		super.api = value;
+	}
+	public override get api(): UmbElementTreeItemContext | undefined {
+		return this.#api;
+	}
+
+	@state()
+	private _name = '';
+
+	/**
+	 * @internal
+	 * Indicates whether the document is a draft, this is controlled internally but present as an attribute as it affects styling.
+	 */
+	@property({ type: Boolean, reflect: true, attribute: 'draft' })
+	protected _isDraft = false;
+
+	#icon: string | null | undefined;
+
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	protected override _extractFlags(item: UmbElementTreeItemModel | undefined) {
+		// Empty on purpose and NOT calling super to prevent doing what the base does. [NL]
+	}
+
+	protected override _getIconName(): string | null | undefined {
+		return this.#icon;
+	}
+
+	override renderLabel() {
+		return html`<span id="label" slot="label" class=${classMap({ draft: this._isDraft })}>${this._name}</span>`;
+	}
+
+	static override styles = [
+		...UmbTreeItemElementBase.styles,
+		css`
+			:host([draft]) #label {
+				opacity: 0.6;
+			}
+			:host([draft]) umb-icon {
+				opacity: 0.6;
+			}
+		`,
+	];
+}
+
+export default UmbElementTreeItemElement;
+
+declare global {
+	interface HTMLElementTagNameMap {
+		'umb-element-tree-item': UmbElementTreeItemElement;
+	}
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree.repository.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree.repository.ts
index b7f9c4b124aa..84b230f6a453 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree.repository.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree.repository.ts
@@ -1,12 +1,22 @@
 import { UMB_ELEMENT_ROOT_ENTITY_TYPE } from '../entity.js';
 import { UmbElementTreeServerDataSource } from './element.tree.server.data-source.js';
-import type { UmbElementTreeItemModel, UmbElementTreeRootModel } from './types.js';
+import type {
+	UmbElementTreeChildrenOfRequestArgs,
+	UmbElementTreeItemModel,
+	UmbElementTreeRootItemsRequestArgs,
+	UmbElementTreeRootModel,
+} from './types.js';
 import { UmbTreeRepositoryBase } from '@umbraco-cms/backoffice/tree';
 import type { UmbApi } from '@umbraco-cms/backoffice/extension-api';
 import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
 
 export class UmbElementTreeRepository
-	extends UmbTreeRepositoryBase<UmbElementTreeItemModel, UmbElementTreeRootModel>
+	extends UmbTreeRepositoryBase<
+		UmbElementTreeItemModel,
+		UmbElementTreeRootModel,
+		UmbElementTreeRootItemsRequestArgs,
+		UmbElementTreeChildrenOfRequestArgs
+	>
 	implements UmbApi
 {
 	constructor(host: UmbControllerHost) {
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree.server.request-manager.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree.server.request-manager.ts
index 6881a231c9ba..a7a5554d5721 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree.server.request-manager.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element-tree.server.request-manager.ts
@@ -1,5 +1,6 @@
 /* eslint-disable local-rules/no-direct-api-import */
 
+import type { UmbElementTreeChildrenOfRequestArgs, UmbElementTreeRootItemsRequestArgs } from './types.js';
 import { ElementService } from '@umbraco-cms/backoffice/external/backend-api';
 import { UmbManagementApiTreeDataRequestManager } from '@umbraco-cms/backoffice/management-api';
 import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
@@ -15,15 +16,29 @@ import type {
 	UmbManagementApiTreeSiblingsFromRequestArgs,
 } from '@umbraco-cms/backoffice/management-api';
 
+interface UmbManagementApiElementTreeRootItemsRequestArgs
+	extends UmbManagementApiTreeRootItemsRequestArgs,
+		Pick<UmbElementTreeRootItemsRequestArgs, 'dataType'> {}
+
+interface UmbManagementApiElementTreeChildrenOfRequestArgs
+	extends UmbManagementApiTreeChildrenOfRequestArgs,
+		Pick<UmbElementTreeChildrenOfRequestArgs, 'dataType'> {}
+
+interface UmbManagementApiElementTreeSiblingsFromRequestArgs extends UmbManagementApiTreeSiblingsFromRequestArgs {
+	dataType?: {
+		unique: string;
+	};
+}
+
 export class UmbManagementApiElementTreeDataRequestManager extends UmbManagementApiTreeDataRequestManager<
 	ElementTreeItemResponseModel,
-	UmbManagementApiTreeRootItemsRequestArgs,
+	UmbManagementApiElementTreeRootItemsRequestArgs,
 	PagedElementTreeItemResponseModel,
-	UmbManagementApiTreeChildrenOfRequestArgs,
+	UmbManagementApiElementTreeChildrenOfRequestArgs,
 	PagedElementTreeItemResponseModel,
 	UmbManagementApiTreeAncestorsOfRequestArgs,
 	Array<ElementTreeItemResponseModel>,
-	UmbManagementApiTreeSiblingsFromRequestArgs,
+	UmbManagementApiElementTreeSiblingsFromRequestArgs,
 	SubsetElementTreeItemResponseModel
 > {
 	constructor(host: UmbControllerHost) {
@@ -31,6 +46,7 @@ export class UmbManagementApiElementTreeDataRequestManager extends UmbManagement
 			getRootItems: (args) =>
 				ElementService.getTreeElementRoot({
 					query: {
+						dataTypeId: args.dataType?.unique,
 						foldersOnly: args.foldersOnly,
 						skip: args.paging.skip,
 						take: args.paging.take,
@@ -41,6 +57,7 @@ export class UmbManagementApiElementTreeDataRequestManager extends UmbManagement
 				ElementService.getTreeElementChildren({
 					query: {
 						parentId: args.parent.unique,
+						dataTypeId: args.dataType?.unique,
 						foldersOnly: args.foldersOnly,
 						skip: args.paging.skip,
 						take: args.paging.take,
@@ -57,6 +74,7 @@ export class UmbManagementApiElementTreeDataRequestManager extends UmbManagement
 			getSiblingsFrom: (args) =>
 				ElementService.getTreeElementSiblings({
 					query: {
+						dataTypeId: args.dataType?.unique,
 						foldersOnly: args.foldersOnly,
 						target: args.paging.target.unique,
 						before: args.paging.takeBefore,
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element.tree.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element.tree.server.data-source.ts
index a278e8738099..c1a72973a6be 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element.tree.server.data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/element.tree.server.data-source.ts
@@ -1,14 +1,14 @@
 import { UMB_ELEMENT_ENTITY_TYPE, UMB_ELEMENT_ROOT_ENTITY_TYPE, UMB_ELEMENT_FOLDER_ENTITY_TYPE } from '../entity.js';
-import type { UmbElementTreeItemModel } from '../types.js';
+import type {
+	UmbElementTreeChildrenOfRequestArgs,
+	UmbElementTreeItemModel,
+	UmbElementTreeRootItemsRequestArgs,
+} from '../types.js';
 import { UmbManagementApiElementTreeDataRequestManager } from './element-tree.server.request-manager.js';
+import { DocumentVariantStateModel } from '@umbraco-cms/backoffice/external/backend-api';
 import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
 import type { ElementTreeItemResponseModel } from '@umbraco-cms/backoffice/external/backend-api';
-import type {
-	UmbTreeAncestorsOfRequestArgs,
-	UmbTreeChildrenOfRequestArgs,
-	UmbTreeDataSource,
-	UmbTreeRootItemsRequestArgs,
-} from '@umbraco-cms/backoffice/tree';
+import type { UmbTreeAncestorsOfRequestArgs, UmbTreeDataSource } from '@umbraco-cms/backoffice/tree';
 
 /**
  * A data source for the Element tree that fetches data from the server
@@ -20,7 +20,7 @@ export class UmbElementTreeServerDataSource
 {
 	#treeRequestManager = new UmbManagementApiElementTreeDataRequestManager(this);
 
-	async getRootItems(args: UmbTreeRootItemsRequestArgs) {
+	async getRootItems(args: UmbElementTreeRootItemsRequestArgs) {
 		const { data, error } = await this.#treeRequestManager.getRootItems(args);
 
 		const mappedData = data
@@ -33,7 +33,7 @@ export class UmbElementTreeServerDataSource
 		return { data: mappedData, error };
 	}
 
-	async getChildrenOf(args: UmbTreeChildrenOfRequestArgs) {
+	async getChildrenOf(args: UmbElementTreeChildrenOfRequestArgs) {
 		const { data, error } = await this.#treeRequestManager.getChildrenOf(args);
 
 		const mappedData = data
@@ -65,7 +65,7 @@ export class UmbElementTreeServerDataSource
 			name: item.name,
 			entityType: item.isFolder ? UMB_ELEMENT_FOLDER_ENTITY_TYPE : UMB_ELEMENT_ENTITY_TYPE,
 			hasChildren: item.hasChildren,
-			isTrashed: false, //item.isTrashed,
+			isTrashed: false,
 			isFolder: item.isFolder,
 			documentType: {
 				unique: item.documentType?.id ?? '',
@@ -73,16 +73,17 @@ export class UmbElementTreeServerDataSource
 				collection: null,
 			},
 			icon: item.isFolder ? 'icon-folder' : (item.documentType?.icon ?? 'icon-document'),
+			flags: item.flags,
 			createDate: item.createDate,
-			variants: item.variants.map((variant) => {
-				return {
-					name: variant.name,
-					culture: variant.culture || null,
-					segment: null, // TODO: add segment to the backend API?
-					state: variant.state,
-					flags: [], //variant.flags,
-				};
-			}),
+			variants: item.isFolder
+				? [{ name: item.name, culture: null, segment: null, state: DocumentVariantStateModel.PUBLISHED, flags: [] }]
+				: item.variants.map((variant) => ({
+						name: variant.name,
+						culture: variant.culture || null,
+						segment: null, // TODO: add segment to the backend API?
+						state: variant.state,
+						flags: variant.flags,
+					})),
 		};
 	}
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/manifests.ts
index 62624822aaf1..9a1b634551a7 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/manifests.ts
@@ -23,9 +23,9 @@ const tree: ManifestTree = {
 const treeItems: Array<ManifestTreeItem> = [
 	{
 		type: 'treeItem',
-		kind: 'default',
 		alias: 'Umb.TreeItem.Element',
 		name: 'Element Tree Item',
+		element: () => import('./element-tree-item.element.js'),
 		api: () => import('./element-tree-item.context.js'),
 		forEntityTypes: [UMB_ELEMENT_ENTITY_TYPE],
 	},
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/types.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/types.ts
index e9198ca527fa..dd6bded78e54 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/tree/types.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/tree/types.ts
@@ -1,12 +1,18 @@
 import type { UmbElementEntityType, UmbElementRootEntityType, UmbElementFolderEntityType } from '../entity.js';
 import type { DocumentVariantStateModel } from '@umbraco-cms/backoffice/external/backend-api';
+import type { UmbEntityFlag, UmbEntityWithFlags } from '@umbraco-cms/backoffice/entity-flag';
 import type { UmbReferenceByUnique } from '@umbraco-cms/backoffice/models';
-import type { UmbTreeItemModel, UmbTreeRootModel } from '@umbraco-cms/backoffice/tree';
+import type {
+	UmbTreeChildrenOfRequestArgs,
+	UmbTreeItemModel,
+	UmbTreeRootItemsRequestArgs,
+	UmbTreeRootModel,
+} from '@umbraco-cms/backoffice/tree';
 
 export type { UmbElementTreeItemContext } from './element-tree-item.context.js';
 export type { UmbElementTreeRepository } from './element-tree.repository.js';
 
-export interface UmbElementTreeItemModel extends UmbTreeItemModel {
+export interface UmbElementTreeItemModel extends Omit<UmbTreeItemModel, 'flags'>, UmbEntityWithFlags {
 	entityType: UmbElementEntityType | UmbElementFolderEntityType;
 	isTrashed: boolean;
 	documentType: {
@@ -27,4 +33,17 @@ export interface UmbElementTreeItemVariantModel {
 	culture: string | null;
 	segment: string | null;
 	state: DocumentVariantStateModel;
+	flags: Array<UmbEntityFlag>;
+}
+
+export interface UmbElementTreeRootItemsRequestArgs extends UmbTreeRootItemsRequestArgs {
+	dataType?: {
+		unique: string;
+	};
+}
+
+export interface UmbElementTreeChildrenOfRequestArgs extends UmbTreeChildrenOfRequestArgs {
+	dataType?: {
+		unique: string;
+	};
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/types.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/types.ts
index 823d6661753c..99ee6449a9c2 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/types.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/types.ts
@@ -20,6 +20,7 @@ export interface UmbElementDetailModel extends UmbContentDetailModel {
 	documentType: {
 		unique: string;
 		collection: null;
+		icon?: string | null;
 	};
 	entityType: UmbElementEntityType;
 	unique: string;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/user-permissions/input-element-granular-user-permission.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/user-permissions/input-element-granular-user-permission.element.ts
index a1dc474d279e..86e2033e8490 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/user-permissions/input-element-granular-user-permission.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/user-permissions/input-element-granular-user-permission.element.ts
@@ -9,13 +9,13 @@ import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbChangeEvent, UmbSelectedEvent } from '@umbraco-cms/backoffice/event';
 import { UMB_ENTITY_USER_PERMISSION_MODAL } from '@umbraco-cms/backoffice/user-permission';
 import { UMB_MODAL_MANAGER_CONTEXT } from '@umbraco-cms/backoffice/modal';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import type { ManifestEntityUserPermission } from '@umbraco-cms/backoffice/user-permission';
 import type { UmbDeselectedEvent } from '@umbraco-cms/backoffice/event';
 import type { UmbModalManagerContext } from '@umbraco-cms/backoffice/modal';
 
 @customElement('umb-input-element-granular-user-permission')
-export class UmbInputElementGranularUserPermissionElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbInputElementGranularUserPermissionElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	#permissions: Array<UmbElementUserPermissionModel> = [];
 	public get permissions(): Array<UmbElementUserPermissionModel> {
 		return this.#permissions;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/utils.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/utils.ts
new file mode 100644
index 000000000000..253e3c230c3e
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/utils.ts
@@ -0,0 +1,64 @@
+import type { UmbElementVariantOptionModel } from './types.js';
+import { DocumentVariantStateModel } from '@umbraco-cms/backoffice/external/backend-api';
+
+type VariantType = UmbElementVariantOptionModel;
+
+const variantStatesOrder = {
+	[DocumentVariantStateModel.PUBLISHED_PENDING_CHANGES]: 1,
+	[DocumentVariantStateModel.PUBLISHED]: 1,
+	[DocumentVariantStateModel.DRAFT]: 2,
+	[DocumentVariantStateModel.NOT_CREATED]: 3,
+	[DocumentVariantStateModel.TRASHED]: 4,
+};
+
+const getVariantStateOrderValue = (variant?: VariantType['variant']) => {
+	const fallbackOrder = 99;
+
+	if (!variant || !variant.state) {
+		return fallbackOrder;
+	}
+
+	return variantStatesOrder[variant.state] || fallbackOrder;
+};
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function compareDefault(a: VariantType, b: VariantType) {
+	return (a.language?.isDefault ? -1 : 1) - (b.language?.isDefault ? -1 : 1);
+}
+
+// Make sure mandatory variants go on top, unless they are published, cause then they already go to the top and then we want to mix them with other published variants.
+// eslint-disable-next-line jsdoc/require-jsdoc
+function compareMandatory(a: VariantType, b: VariantType) {
+	return a.variant?.state === DocumentVariantStateModel.PUBLISHED_PENDING_CHANGES ||
+		a.variant?.state === DocumentVariantStateModel.PUBLISHED
+		? 0
+		: (a.language?.isMandatory ? -1 : 1) - (b.language?.isMandatory ? -1 : 1);
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function compareState(a: VariantType, b: VariantType) {
+	return getVariantStateOrderValue(a.variant) - getVariantStateOrderValue(b.variant);
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function compareName(a: VariantType, b: VariantType) {
+	const nameA = a.language?.name;
+	const nameB = b.language?.name;
+
+	// If both names are missing, consider them equal.
+	if (!nameA && !nameB) return 0;
+	// If only one name is missing, sort the defined name first.
+	if (!nameA) return 1;
+	if (!nameB) return -1;
+
+	return nameA.localeCompare(nameB);
+}
+/**
+ * Sorts element variants based on multiple criteria:
+ * @param {VariantType} a - First variant to compare
+ * @param {VariantType} b - Second variant to compare
+ * @returns {number} - Sorting value
+ */
+export function sortVariants(a: VariantType, b: VariantType) {
+	return compareDefault(a, b) || compareMandatory(a, b) || compareState(a, b) || compareName(a, b);
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace-split-view-variant-selector.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace-split-view-variant-selector.element.ts
new file mode 100644
index 000000000000..fc12a4beb0d3
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace-split-view-variant-selector.element.ts
@@ -0,0 +1,74 @@
+import type { UmbElementVariantOptionModel } from '../types.js';
+import { sortVariants } from '../utils.js';
+import { UMB_ELEMENT_PUBLISHING_WORKSPACE_CONTEXT } from '../publishing/index.js';
+import { customElement, html, state } from '@umbraco-cms/backoffice/external/lit';
+import { DocumentVariantStateModel } from '@umbraco-cms/backoffice/external/backend-api';
+import { UmbWorkspaceSplitViewVariantSelectorElement } from '@umbraco-cms/backoffice/workspace';
+
+@customElement('umb-element-workspace-split-view-variant-selector')
+export class UmbElementWorkspaceSplitViewVariantSelectorElement extends UmbWorkspaceSplitViewVariantSelectorElement<UmbElementVariantOptionModel> {
+	protected override _variantSorter = sortVariants;
+
+	@state()
+	private _variantsWithPendingChanges: Array<any> = [];
+
+	#elementPublishingWorkspaceContext?: typeof UMB_ELEMENT_PUBLISHING_WORKSPACE_CONTEXT.TYPE;
+
+	#publishStateLocalizationMap = {
+		[DocumentVariantStateModel.DRAFT]: 'content_unpublished',
+		[DocumentVariantStateModel.PUBLISHED]: 'content_published',
+		// TODO: The pending changes state can be removed once the management Api removes this state
+		// We only keep it here to make typescript happy
+		// We should also make our own state model for this
+		[DocumentVariantStateModel.PUBLISHED_PENDING_CHANGES]: 'content_published',
+		[DocumentVariantStateModel.NOT_CREATED]: 'content_notCreated',
+		[DocumentVariantStateModel.TRASHED]: 'mediaPicker_trashed',
+	};
+
+	constructor() {
+		super();
+		this.consumeContext(UMB_ELEMENT_PUBLISHING_WORKSPACE_CONTEXT, (instance) => {
+			this.#elementPublishingWorkspaceContext = instance;
+			this.#observePendingChanges();
+		});
+	}
+
+	#observePendingChanges() {
+		this.observe(
+			this.#elementPublishingWorkspaceContext?.publishedPendingChanges.variantsWithChanges,
+			(variants) => {
+				this._variantsWithPendingChanges = variants || [];
+			},
+			'_observePendingChanges',
+		);
+	}
+
+	#hasPendingChanges(variant: UmbElementVariantOptionModel) {
+		return this._variantsWithPendingChanges.some((x) => x.variantId.compare(variant));
+	}
+
+	#getVariantState(variantOption: UmbElementVariantOptionModel) {
+		let term =
+			this.#publishStateLocalizationMap[variantOption.variant?.state || DocumentVariantStateModel.NOT_CREATED];
+
+		if (
+			(variantOption.variant?.state === DocumentVariantStateModel.PUBLISHED ||
+				variantOption.variant?.state === DocumentVariantStateModel.PUBLISHED_PENDING_CHANGES) &&
+			this.#hasPendingChanges(variantOption)
+		) {
+			term = 'content_publishedPendingChanges';
+		}
+
+		return this.localize.term(term);
+	}
+
+	protected override _renderVariantDetails(variantOption: UmbElementVariantOptionModel) {
+		return html`${this.#getVariantState(variantOption)}`;
+	}
+}
+
+declare global {
+	interface HTMLElementTagNameMap {
+		'umb-element-workspace-split-view-variant-selector': UmbElementWorkspaceSplitViewVariantSelectorElement;
+	}
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace-split-view.element.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace-split-view.element.ts
index 4faeb5eab99b..b5e6c791e4f2 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace-split-view.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace-split-view.element.ts
@@ -1,9 +1,11 @@
 import { UMB_ELEMENT_WORKSPACE_ALIAS, UMB_ELEMENT_WORKSPACE_CONTEXT } from './constants.js';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
-import { css, html, nothing, customElement, state, repeat } from '@umbraco-cms/backoffice/external/lit';
+import { css, html, nothing, customElement, state, repeat, ifDefined } from '@umbraco-cms/backoffice/external/lit';
 import type { UmbActiveVariant } from '@umbraco-cms/backoffice/workspace';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 
+import './element-workspace-split-view-variant-selector.element.js';
+
 @customElement('umb-element-workspace-split-view')
 export class UmbElementWorkspaceSplitViewElement extends UmbLitElement {
 	// TODO: Refactor: use the split view context token:
@@ -12,16 +14,24 @@ export class UmbElementWorkspaceSplitViewElement extends UmbLitElement {
 	@state()
 	private _variants?: Array<UmbActiveVariant>;
 
+	@state()
+	private _icon?: string;
+
+	@state()
+	private _loading = true;
+
 	constructor() {
 		super();
 		// TODO: Refactor: use a split view workspace context token:
 		this.consumeContext(UMB_ELEMENT_WORKSPACE_CONTEXT, (context) => {
 			this._workspaceContext = context;
-			this._observeActiveVariantInfo();
+			this.#observeActiveVariantInfo();
+			this.#observeIcon();
+			this.#observeLoading();
 		});
 	}
 
-	private _observeActiveVariantInfo() {
+	#observeActiveVariantInfo() {
 		if (!this._workspaceContext) return;
 		this.observe(
 			this._workspaceContext.splitView.activeVariantsInfo,
@@ -32,6 +42,26 @@ export class UmbElementWorkspaceSplitViewElement extends UmbLitElement {
 		);
 	}
 
+	#observeIcon() {
+		this.observe(
+			this._workspaceContext?.contentTypeIcon,
+			(icon) => {
+				this._icon = icon ?? undefined;
+			},
+			'observeIcon',
+		);
+	}
+
+	#observeLoading() {
+		this.observe(
+			this._workspaceContext?.loading.isOn,
+			(loading) => {
+				this._loading = loading ?? false;
+			},
+			'observeLoading',
+		);
+	}
+
 	override render() {
 		return this._variants
 			? html`<div id="splitViews">
@@ -41,8 +71,13 @@ export class UmbElementWorkspaceSplitViewElement extends UmbLitElement {
 								view.index + '_' + (view.culture ?? '') + '_' + (view.segment ?? '') + '_' + this._variants!.length,
 							(view) => html`
 								<umb-workspace-split-view
-									.splitViewIndex=${view.index}
-									.displayNavigation=${view.index === this._variants!.length - 1}></umb-workspace-split-view>
+									.loading=${this._loading}
+									.displayNavigation=${view.index === this._variants!.length - 1}
+									.splitViewIndex=${view.index}>
+									<umb-icon slot="icon" name=${ifDefined(this._icon)}></umb-icon>
+									<umb-element-workspace-split-view-variant-selector
+										slot="variant-selector"></umb-element-workspace-split-view-variant-selector>
+								</umb-workspace-split-view>
 							`,
 						)}
 					</div>
@@ -68,10 +103,6 @@ export class UmbElementWorkspaceSplitViewElement extends UmbLitElement {
 				width: 100%;
 				height: calc(100% - var(--umb-footer-layout-height));
 			}
-
-			#breadcrumbs {
-				margin: 0 var(--uui-size-layout-1);
-			}
 		`,
 	];
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace.context.ts b/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace.context.ts
index dd76fde5b270..e413976c147d 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace.context.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/elements/workspace/element-workspace.context.ts
@@ -1,12 +1,19 @@
 import { UMB_CREATE_ELEMENT_WORKSPACE_PATH_PATTERN, UMB_EDIT_ELEMENT_WORKSPACE_PATH_PATTERN } from '../paths.js';
 import { UMB_ELEMENT_ENTITY_TYPE } from '../entity.js';
-import { UMB_ELEMENT_DETAIL_REPOSITORY_ALIAS } from '../repository/detail/constants.js';
 import type { UmbElementDetailRepository } from '../repository/index.js';
 import type { UmbElementDetailModel, UmbElementVariantModel } from '../types.js';
-import { UMB_ELEMENT_COLLECTION_ALIAS } from '../collection/constants.js';
 import { UmbElementValidationRepository } from '../repository/validation/index.js';
+import {
+	UMB_ELEMENT_COLLECTION_ALIAS,
+	UMB_ELEMENT_DETAIL_REPOSITORY_ALIAS,
+	UMB_ELEMENT_SAVE_MODAL,
+	UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS,
+	UMB_USER_PERMISSION_ELEMENT_CREATE,
+	UMB_USER_PERMISSION_ELEMENT_UPDATE,
+} from '../constants.js';
 import { UMB_ELEMENT_WORKSPACE_ALIAS } from './constants.js';
 import { UmbElementWorkspacePropertyDatasetContext } from './property-dataset-context/element-workspace-property-dataset-context.js';
+import { createExtensionApiByAlias } from '@umbraco-cms/backoffice/extension-registry';
 import { UmbContentDetailWorkspaceContextBase } from '@umbraco-cms/backoffice/content';
 import { UmbDocumentTypeDetailRepository } from '@umbraco-cms/backoffice/document-type';
 import {
@@ -41,6 +48,8 @@ export class UmbElementWorkspaceContext
 {
 	readonly contentTypeUnique = this._data.createObservablePartOfCurrent((data) => data?.documentType.unique);
 
+	readonly contentTypeIcon = this._data.createObservablePartOfCurrent((data) => data?.documentType.icon || null);
+
 	readonly isTrashed = this._data.createObservablePartOfCurrent((data) => data?.isTrashed);
 
 	#actionEventContext?: typeof UMB_ACTION_EVENT_CONTEXT.TYPE;
@@ -59,7 +68,7 @@ export class UmbElementWorkspaceContext
 			ignoreValidationResultOnSubmit: true,
 			contentVariantScaffold: UMB_DOCUMENT_DETAIL_MODEL_VARIANT_SCAFFOLD,
 			contentTypePropertyName: 'documentType',
-			// TODO: Add a save modal token for Element workspace [LK]
+			saveModalToken: UMB_ELEMENT_SAVE_MODAL,
 		});
 
 		this.consumeContext(UMB_ACTION_EVENT_CONTEXT, (actionEventContext) => {
@@ -78,6 +87,25 @@ export class UmbElementWorkspaceContext
 			null,
 		);
 
+		this.observe(
+			this.isNew,
+			(isNew) => {
+				if (isNew === undefined) return;
+				if (isNew) {
+					this.#enforceUserPermission(
+						UMB_USER_PERMISSION_ELEMENT_CREATE,
+						'You do not have permission to create elements.',
+					);
+				} else {
+					this.#enforceUserPermission(
+						UMB_USER_PERMISSION_ELEMENT_UPDATE,
+						'You do not have permission to update elements.',
+					);
+				}
+			},
+			null,
+		);
+
 		this.observe(this.isTrashed, (isTrashed) => this.#onTrashStateChange(isTrashed));
 
 		this.routes.setRoutes([
@@ -109,6 +137,22 @@ export class UmbElementWorkspaceContext
 		]);
 	}
 
+	#enforceUserPermission(verb: string, message: string) {
+		// We set the initial permission state to false because the condition is false by default and only execute the callback if it changes.
+		this.#handleUserPermissionChange(verb, false, message);
+
+		createExtensionApiByAlias(this, UMB_ELEMENT_USER_PERMISSION_CONDITION_ALIAS, [
+			{
+				config: {
+					allOf: [verb],
+				},
+				onChange: (permitted: boolean) => {
+					this.#handleUserPermissionChange(verb, permitted, message);
+				},
+			},
+		]);
+	}
+
 	async create(parent: UmbEntityModel, documentTypeUnique: string) {
 		return this.createScaffold({
 			parent,
@@ -137,11 +181,35 @@ export class UmbElementWorkspaceContext
 		return new UmbElementWorkspacePropertyDatasetContext(host, this, variantId);
 	}
 
+	protected override async _handleSave() {
+		const elementStyle = (this.getHostElement() as HTMLElement).style;
+		elementStyle.setProperty('--uui-color-invalid', 'var(--uui-color-warning)');
+		elementStyle.setProperty('--uui-color-invalid-emphasis', 'var(--uui-color-warning-emphasis)');
+		elementStyle.setProperty('--uui-color-invalid-standalone', 'var(--uui-color-warning-standalone)');
+		elementStyle.setProperty('--uui-color-invalid-contrast', 'var(--uui-color-warning-contrast)');
+		await super._handleSave();
+	}
+
 	override resetState(): void {
 		super.resetState();
 		this.#isTrashedContext.setIsTrashed(false);
 	}
 
+	async #handleUserPermissionChange(identifier: string, permitted: boolean, message: string) {
+		if (permitted) {
+			this.readOnlyGuard?.removeRule(identifier);
+			return;
+		}
+
+		this.readOnlyGuard?.addRule({
+			unique: identifier,
+			message,
+			/* This guard is a bit backwards. The rule is permitted to be read-only.
+			If the user does not have permission, we set it to true = permitted to be read-only. */
+			permitted: true,
+		});
+	}
+
 	#addEventListeners() {
 		this.#actionEventContext?.addEventListener(UmbEntityTrashedEvent.TYPE, this.#onRecycleBinEvent as EventListener);
 		this.#actionEventContext?.addEventListener(
diff --git a/src/Umbraco.Web.UI.Client/src/packages/embedded-media/modal/embedded-media-modal.element.ts b/src/Umbraco.Web.UI.Client/src/packages/embedded-media/modal/embedded-media-modal.element.ts
index e91c24cbcd04..2d839bed6f8e 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/embedded-media/modal/embedded-media-modal.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/embedded-media/modal/embedded-media-modal.element.ts
@@ -2,9 +2,14 @@ import { UmbOEmbedRepository } from '../repository/oembed.repository.js';
 import type { UmbEmbeddedMediaModalData, UmbEmbeddedMediaModalValue } from './embedded-media-modal.token.js';
 import { css, html, unsafeHTML, when, customElement, state } from '@umbraco-cms/backoffice/external/lit';
 import { umbFocus } from '@umbraco-cms/backoffice/lit-element';
+import { debounce } from '@umbraco-cms/backoffice/utils';
 import { UmbModalBaseElement } from '@umbraco-cms/backoffice/modal';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
 import type { UUIButtonState, UUIInputEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UmbInputDimensionsElement } from '@umbraco-cms/backoffice/components';
+
+const DEFAULT_WIDTH = 500;
+const DEFAULT_HEIGHT = Math.round(500 / (16 / 9));
 
 @customElement('umb-embedded-media-modal')
 export class UmbEmbeddedMediaModalElement extends UmbModalBaseElement<
@@ -18,10 +23,13 @@ export class UmbEmbeddedMediaModalElement extends UmbModalBaseElement<
 	private _loading?: UUIButtonState;
 
 	@state()
-	private _width = 360;
+	private _width = DEFAULT_WIDTH;
+
+	@state()
+	private _height = DEFAULT_HEIGHT;
 
 	@state()
-	private _height = 240;
+	private _constrain = true;
 
 	@state()
 	private _url = '';
@@ -29,9 +37,11 @@ export class UmbEmbeddedMediaModalElement extends UmbModalBaseElement<
 	override connectedCallback() {
 		super.connectedCallback();
 
-		if (this.data?.width) this._width = this.data.width;
-		if (this.data?.height) this._height = this.data.height;
-		if (this.data?.constrain) this.value = { ...this.value, constrain: this.data.constrain };
+		if (this.data?.width) this._width = this.data.width > 0 ? this.data.width : DEFAULT_WIDTH;
+		if (this.data?.height) this._height = this.data.height > 0 ? this.data.height : DEFAULT_HEIGHT;
+		if (this.data?.constrain !== undefined) this._constrain = this.data.constrain;
+
+		this.value = { ...this.value, constrain: this._constrain, width: this._width, height: this._height };
 
 		if (this.data?.url) {
 			this._url = this.data.url;
@@ -62,24 +72,29 @@ export class UmbEmbeddedMediaModalElement extends UmbModalBaseElement<
 		this._url = e.target.value as string;
 	}
 
-	#onWidthChange(e: UUIInputEvent) {
-		this._width = parseInt(e.target.value as string, 10);
-		this.value = { ...this.value, width: this._width };
-		this.#getPreview();
-	}
+	#debouncedGetPreview = debounce(() => this.#getPreview(), 500);
 
-	#onHeightChange(e: UUIInputEvent) {
-		this._height = parseInt(e.target.value as string, 10);
-		this.value = { ...this.value, height: this._height };
-		this.#getPreview();
+	#onDimensionsChange(e: Event) {
+		const target = e.target as UmbInputDimensionsElement;
+		this._width = target.width ?? DEFAULT_WIDTH;
+		this._height = target.height ?? DEFAULT_HEIGHT;
+		this._constrain = target.locked;
+		this.value = { ...this.value, width: this._width, height: this._height, constrain: this._constrain };
+		this.#debouncedGetPreview();
 	}
 
-	#onConstrainChange() {
-		const constrain = !this.value?.constrain;
-		this.value = { ...this.value, constrain };
+	protected override updated() {
+		// Iframes don't have intrinsic aspect ratios like images, so height:auto collapses to 150px.
+		// Read the provider's width/height attributes and apply aspect-ratio to keep proportions.
+		const iframe = this.renderRoot.querySelector<HTMLIFrameElement>('#preview iframe');
+		if (iframe?.width && iframe?.height) {
+			iframe.style.aspectRatio = `${iframe.width} / ${iframe.height}`;
+			iframe.style.height = 'auto';
+		}
 	}
 
 	override render() {
+		const isDisabled = !this.#validUrl;
 		return html`
 			<umb-body-layout headline="Embed">
 				<uui-box>
@@ -96,41 +111,29 @@ export class UmbEmbeddedMediaModalElement extends UmbModalBaseElement<
 						</div>
 					</umb-property-layout>
 
+					<umb-property-layout
+						label=${this.localize.term('general_dimensions')}
+						description=${this.localize.term('embeddedMedia_dimensionsDescription')}
+						orientation="vertical">
+						<umb-input-dimensions
+							slot="editor"
+							.width=${this._width}
+							.height=${this._height}
+							.locked=${this._constrain}
+							?disabled=${isDisabled}
+							@change=${this.#onDimensionsChange}></umb-input-dimensions>
+					</umb-property-layout>
+
 					${when(
 						this.#validUrl !== undefined,
 						() =>
 							html` <umb-property-layout label=${this.localize.term('general_preview')} orientation="vertical">
 								<div slot="editor">
 									${when(this._loading === 'waiting', () => html`<uui-loader-circle></uui-loader-circle>`)}
-									${when(this.value?.markup, () => html`${unsafeHTML(this.value.markup)}`)}
+									${when(this.value?.markup, () => html`<div id="preview">${unsafeHTML(this.value.markup)}</div>`)}
 								</div>
 							</umb-property-layout>`,
 					)}
-
-					<umb-property-layout label=${this.localize.term('general_width')} orientation="vertical">
-						<uui-input
-							slot="editor"
-							.value=${this._width}
-							type="number"
-							@change=${this.#onWidthChange}
-							?disabled=${this.#validUrl ? false : true}></uui-input>
-					</umb-property-layout>
-
-					<umb-property-layout label=${this.localize.term('general_height')} orientation="vertical">
-						<uui-input
-							slot="editor"
-							.value=${this._height}
-							type="number"
-							@change=${this.#onHeightChange}
-							?disabled=${this.#validUrl ? false : true}></uui-input>
-					</umb-property-layout>
-
-					<umb-property-layout label=${this.localize.term('general_constrainProportions')} orientation="vertical">
-						<uui-toggle
-							slot="editor"
-							@change=${this.#onConstrainChange}
-							.checked=${this.value?.constrain ?? false}></uui-toggle>
-					</umb-property-layout>
 				</uui-box>
 
 				<uui-button
@@ -157,12 +160,17 @@ export class UmbEmbeddedMediaModalElement extends UmbModalBaseElement<
 				--uui-button-border-radius: 0;
 			}
 
-			umb-property-layout:first-child {
-				padding-top: 0;
+			#preview {
+				max-width: 100%;
+				overflow: hidden;
+
+				> *:first-child {
+					max-width: 100%;
+				}
 			}
 
-			umb-property-layout:last-child {
-				padding-bottom: 0;
+			umb-property-layout:first-child {
+				padding-top: 0;
 			}
 		`,
 	];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/language/components/input-language/input-language.element.ts b/src/Umbraco.Web.UI.Client/src/packages/language/components/input-language/input-language.element.ts
index 9a462669437c..4393c3bb77b8 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/language/components/input-language/input-language.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/language/components/input-language/input-language.element.ts
@@ -5,11 +5,11 @@ import { splitStringToArray } from '@umbraco-cms/backoffice/utils';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbSorterController } from '@umbraco-cms/backoffice/sorter';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import type { UmbRepositoryItemsStatus } from '@umbraco-cms/backoffice/repository';
 
 @customElement('umb-input-language')
-export class UmbInputLanguageElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbInputLanguageElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	#sorter = new UmbSorterController<string>(this, {
 		getUniqueOfElement: (element) => {
 			return element.id;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/media/media-types/repository/detail/media-type-detail.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/media/media-types/repository/detail/media-type-detail.server.data-source.ts
index 02df61279dcc..33c7a6ac0aa8 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/media/media-types/repository/detail/media-type-detail.server.data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/media/media-types/repository/detail/media-type-detail.server.data-source.ts
@@ -40,7 +40,6 @@ export class UmbMediaTypeDetailServerDataSource
 			variesByCulture: false,
 			variesBySegment: false,
 			isElement: false,
-			allowedInLibrary: false,
 			properties: [],
 			containers: [],
 			allowedContentTypes: [],
@@ -106,7 +105,7 @@ export class UmbMediaTypeDetailServerDataSource
 			variesByCulture: model.variesByCulture,
 			variesBySegment: model.variesBySegment,
 			isElement: model.isElement,
-			allowedInLibrary: model.allowedInLibrary,
+			allowedInLibrary: false,
 			properties: model.properties.map((property) => {
 				return {
 					id: property.unique,
@@ -165,7 +164,7 @@ export class UmbMediaTypeDetailServerDataSource
 			variesByCulture: model.variesByCulture,
 			variesBySegment: model.variesBySegment,
 			isElement: model.isElement,
-			allowedInLibrary: model.allowedInLibrary,
+			allowedInLibrary: false,
 			properties: model.properties.map((property) => {
 				return {
 					id: property.unique,
@@ -225,7 +224,6 @@ export class UmbMediaTypeDetailServerDataSource
 			variesByCulture: data.variesByCulture,
 			variesBySegment: data.variesBySegment,
 			isElement: data.isElement,
-			allowedInLibrary: data.allowedInLibrary,
 			properties: data.properties.map((property) => {
 				return {
 					id: property.id,
diff --git a/src/Umbraco.Web.UI.Client/src/packages/media/media/audit-log/info-app/media-history-workspace-info-app.element.ts b/src/Umbraco.Web.UI.Client/src/packages/media/media/audit-log/info-app/media-history-workspace-info-app.element.ts
index 1bb54d5f61c9..08b22160770d 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/media/media/audit-log/info-app/media-history-workspace-info-app.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/media/media/audit-log/info-app/media-history-workspace-info-app.element.ts
@@ -1,11 +1,11 @@
 import { UMB_MEDIA_WORKSPACE_CONTEXT } from '../../workspace/constants.js';
 import type { UmbMediaAuditLogModel } from '../types.js';
 import { UmbMediaAuditLogRepository } from '../repository/index.js';
-import { getMediaHistoryTagStyleAndText, TimeOptions } from './utils.js';
+import { getMediaHistoryTagStyleAndText } from './utils.js';
 import { css, html, customElement, state, nothing, repeat, when } from '@umbraco-cms/backoffice/external/lit';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
-import { UmbPaginationManager } from '@umbraco-cms/backoffice/utils';
+import { UmbPaginationManager, UMB_DATE_TIME_FORMAT_OPTIONS } from '@umbraco-cms/backoffice/utils';
 import type { UUIPaginationEvent } from '@umbraco-cms/backoffice/external/uui';
 import type { UmbUserItemModel } from '@umbraco-cms/backoffice/user';
 import { UmbUserItemRepository } from '@umbraco-cms/backoffice/user';
@@ -115,7 +115,7 @@ export class UmbMediaHistoryWorkspaceInfoAppElement extends UmbLitElement {
 
 							return html`<umb-history-item
 								.name=${user?.name ?? 'Unknown'}
-								.detail=${this.localize.date(item.timestamp, TimeOptions)}>
+								.detail=${this.localize.date(item.timestamp, UMB_DATE_TIME_FORMAT_OPTIONS)}>
 								<umb-user-avatar
 									slot="avatar"
 									.name=${user?.name}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/media/media/audit-log/info-app/utils.ts b/src/Umbraco.Web.UI.Client/src/packages/media/media/audit-log/info-app/utils.ts
index 15b75d1f6e75..319f7896e0cd 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/media/media/audit-log/info-app/utils.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/media/media/audit-log/info-app/utils.ts
@@ -68,12 +68,3 @@ export function getMediaHistoryTagStyleAndText(type: UmbMediaAuditLogType): Hist
 			};
 	}
 }
-
-export const TimeOptions: Intl.DateTimeFormatOptions = {
-	year: 'numeric',
-	month: 'long',
-	day: 'numeric',
-	hour: 'numeric',
-	minute: 'numeric',
-	second: 'numeric',
-};
diff --git a/src/Umbraco.Web.UI.Client/src/packages/media/media/dropzone/media-dropzone.manager.ts b/src/Umbraco.Web.UI.Client/src/packages/media/media/dropzone/media-dropzone.manager.ts
index aa1f3479313f..0e5f6887aa21 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/media/media/dropzone/media-dropzone.manager.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/media/media/dropzone/media-dropzone.manager.ts
@@ -267,7 +267,9 @@ export class UmbMediaDropzoneManager extends UmbDropzoneManager {
 		const value = await umbOpenModal(this, UMB_DROPZONE_MEDIA_TYPE_PICKER_MODAL, { data: { options } }).catch(
 			() => undefined,
 		);
-		return value?.mediaTypeUnique;
+		if (!value) return undefined; // cancelled
+		// Auto-pick: mediaTypeUnique is undefined → use the server's preferred type (first in the list)
+		return value.mediaTypeUnique ?? options[0]?.unique;
 	}
 
 	async #createOneMediaItem(item: UmbUploadableItem) {
diff --git a/src/Umbraco.Web.UI.Client/src/packages/media/media/modals/media-caption-alt-text/media-caption-alt-text-modal.element.ts b/src/Umbraco.Web.UI.Client/src/packages/media/media/modals/media-caption-alt-text/media-caption-alt-text-modal.element.ts
index 82d8ae9c6fe3..4a1bcab4abfe 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/media/media/modals/media-caption-alt-text/media-caption-alt-text-modal.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/media/media/modals/media-caption-alt-text/media-caption-alt-text-modal.element.ts
@@ -4,9 +4,11 @@ import type {
 	UmbMediaCaptionAltTextModalData,
 	UmbMediaCaptionAltTextModalValue,
 } from './media-caption-alt-text-modal.token.js';
-import { css, html, customElement } from '@umbraco-cms/backoffice/external/lit';
+import { css, html, customElement, state } from '@umbraco-cms/backoffice/external/lit';
+import { imageSize } from '@umbraco-cms/backoffice/utils';
 import { UmbModalBaseElement } from '@umbraco-cms/backoffice/modal';
 import type { UUIInputEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UmbInputDimensionsElement } from '@umbraco-cms/backoffice/components';
 
 @customElement('umb-media-caption-alt-text-modal')
 export class UmbMediaCaptionAltTextModalElement extends UmbModalBaseElement<
@@ -17,6 +19,12 @@ export class UmbMediaCaptionAltTextModalElement extends UmbModalBaseElement<
 	readonly #mediaDetailRepository = new UmbMediaDetailRepository(this);
 	readonly #mediaUrlRepository = new UmbMediaUrlRepository(this);
 
+	@state()
+	private _naturalWidth?: number;
+
+	@state()
+	private _naturalHeight?: number;
+
 	override connectedCallback() {
 		super.connectedCallback();
 		this.#mediaUnique = this.data?.mediaUnique;
@@ -30,16 +38,54 @@ export class UmbMediaCaptionAltTextModalElement extends UmbModalBaseElement<
 
 		const { data: mediaUrlData } = await this.#mediaUrlRepository.requestItems([this.#mediaUnique]);
 
+		const url = mediaUrlData?.[0].url ?? '';
+
 		this.value = {
 			...this.value,
 			altText: this.value?.altText ?? mediaData.variants[0].name,
-			url: mediaUrlData?.[0].url ?? '',
+			url,
 		};
+
+		if (url) {
+			try {
+				const dims = await imageSize(url);
+				let naturalWidth = dims.naturalWidth;
+				let naturalHeight = dims.naturalHeight;
+
+				// Cap natural dimensions to maxImageSize proportionally
+				const maxSize = this.data?.maxImageSize;
+				if (maxSize && (naturalWidth > maxSize || naturalHeight > maxSize)) {
+					const ratio = Math.min(maxSize / naturalWidth, maxSize / naturalHeight);
+					naturalWidth = Math.round(naturalWidth * ratio);
+					naturalHeight = Math.round(naturalHeight * ratio);
+				}
+
+				this._naturalWidth = naturalWidth;
+				this._naturalHeight = naturalHeight;
+
+				// Auto-populate dimensions from natural size if not already set
+				if (!this.value.width) {
+					this.value = {
+						...this.value,
+						width: naturalWidth,
+						height: naturalHeight,
+					};
+				}
+			} catch {
+				// If image dimensions cannot be resolved, leave width/height unset.
+			}
+		}
+	}
+
+	#onDimensionsChange(e: Event) {
+		const target = e.target as UmbInputDimensionsElement;
+		this.value = { ...this.value, width: target.width, height: target.height };
 	}
 
 	override render() {
 		return html`
 			<umb-body-layout .headline=${this.localize.term('defaultdialogs_editSelectedMedia')}>
+				<uui-box>
 				<div id="wrapper">
 					<uui-label for="alt-text">${this.localize.term('content_altTextOptional')}</uui-label>
 					<uui-input
@@ -57,11 +103,24 @@ export class UmbMediaCaptionAltTextModalElement extends UmbModalBaseElement<
 						@input=${(e: UUIInputEvent) =>
 							(this.value = { ...this.value, caption: e.target.value as string })}></uui-input>
 
+					<umb-input-dimensions
+						.width=${this.value?.width}
+						.height=${this.value?.height}
+						.naturalWidth=${this._naturalWidth}
+						.naturalHeight=${this._naturalHeight}
+						@change=${this.#onDimensionsChange}></umb-input-dimensions>
+
 					<figure id="mainobject">
-						<img src=${this.value?.url ?? ''} alt=${this.value?.altText ?? ''} />
+						<img
+							src=${this.value?.url ?? ''}
+							alt=${this.value?.altText ?? ''}
+							style=${this.value?.width && this.value?.height
+								? `width: ${this.value.width}px; aspect-ratio: ${this.value.width} / ${this.value.height}`
+								: ''} />
 						<figcaption>${this.value?.caption ?? ''}</figcaption>
 					</figure>
 				</div>
+				</uui-box>
 				<div slot="actions">
 					<uui-button label=${this.localize.term('general_close')} @click=${this._rejectModal}></uui-button>
 					<uui-button
@@ -85,14 +144,20 @@ export class UmbMediaCaptionAltTextModalElement extends UmbModalBaseElement<
 				flex-direction: column;
 			}
 
+			umb-input-dimensions {
+				margin-bottom: var(--uui-size-layout-1);
+			}
+
 			#mainobject {
 				display: flex;
 				flex-direction: column;
+				align-items: center;
 				max-width: 100%;
 
 				img {
 					max-width: 100%;
 					height: auto;
+					transition: aspect-ratio 0.3s ease;
 				}
 			}
 		`,
diff --git a/src/Umbraco.Web.UI.Client/src/packages/media/media/modals/media-caption-alt-text/media-caption-alt-text-modal.token.ts b/src/Umbraco.Web.UI.Client/src/packages/media/media/modals/media-caption-alt-text/media-caption-alt-text-modal.token.ts
index dadf0318f3f5..2c35ba0013ae 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/media/media/modals/media-caption-alt-text/media-caption-alt-text-modal.token.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/media/media/modals/media-caption-alt-text/media-caption-alt-text-modal.token.ts
@@ -2,12 +2,15 @@ import { UmbModalToken } from '@umbraco-cms/backoffice/modal';
 
 export interface UmbMediaCaptionAltTextModalData {
 	mediaUnique: string;
+	maxImageSize?: number;
 }
 
 export type UmbMediaCaptionAltTextModalValue = {
 	altText?: string;
 	caption?: string;
 	url: string;
+	width?: number;
+	height?: number;
 };
 
 export const UMB_MEDIA_CAPTION_ALT_TEXT_MODAL = new UmbModalToken<
diff --git a/src/Umbraco.Web.UI.Client/src/packages/media/media/workspace/views/info/media-workspace-view-info.element.ts b/src/Umbraco.Web.UI.Client/src/packages/media/media/workspace/views/info/media-workspace-view-info.element.ts
index 630631bed30b..4c6ad5b284f7 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/media/media/workspace/views/info/media-workspace-view-info.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/media/media/workspace/views/info/media-workspace-view-info.element.ts
@@ -1,16 +1,16 @@
 import { UMB_MEDIA_WORKSPACE_CONTEXT } from '../../media-workspace.context-token.js';
-import { TimeOptions } from '../../../audit-log/info-app/utils.js';
 import { css, customElement, html, ifDefined, nothing, state } from '@umbraco-cms/backoffice/external/lit';
+import { createExtensionApiByAlias } from '@umbraco-cms/backoffice/extension-registry';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import type { UmbMediaTypeItemModel } from '@umbraco-cms/backoffice/media-type';
-import { UMB_MEDIA_TYPE_ENTITY_TYPE, UmbMediaTypeItemRepository } from '@umbraco-cms/backoffice/media-type';
+import { UmbMediaTypeItemRepository, UMB_MEDIA_TYPE_ENTITY_TYPE } from '@umbraco-cms/backoffice/media-type';
 import { UmbModalRouteRegistrationController } from '@umbraco-cms/backoffice/router';
 import { UmbTextStyles } from '@umbraco-cms/backoffice/style';
-import { UMB_WORKSPACE_MODAL } from '@umbraco-cms/backoffice/workspace';
-import { createExtensionApiByAlias } from '@umbraco-cms/backoffice/extension-registry';
+import { UMB_DATE_TIME_FORMAT_OPTIONS } from '@umbraco-cms/backoffice/utils';
+import { UMB_IS_TRASHED_ENTITY_CONTEXT } from '@umbraco-cms/backoffice/recycle-bin';
 import { UMB_SECTION_USER_PERMISSION_CONDITION_ALIAS } from '@umbraco-cms/backoffice/section';
 import { UMB_SETTINGS_SECTION_ALIAS } from '@umbraco-cms/backoffice/settings';
-import { UMB_IS_TRASHED_ENTITY_CONTEXT } from '@umbraco-cms/backoffice/recycle-bin';
+import { UMB_WORKSPACE_MODAL } from '@umbraco-cms/backoffice/workspace';
+import type { UmbMediaTypeItemModel } from '@umbraco-cms/backoffice/media-type';
 
 @customElement('umb-media-workspace-view-info')
 export class UmbMediaWorkspaceViewInfoElement extends UmbLitElement {
@@ -169,7 +169,7 @@ export class UmbMediaWorkspaceViewInfoElement extends UmbLitElement {
 			<div class="general-item">
 				<strong><umb-localize key="content_createDate"></umb-localize></strong>
 				<span>
-					<umb-localize-date .date=${this._createDate} .options=${TimeOptions}></umb-localize-date>
+					<umb-localize-date .date=${this._createDate} .options=${UMB_DATE_TIME_FORMAT_OPTIONS}></umb-localize-date>
 				</span>
 			</div>
 		`;
@@ -181,7 +181,7 @@ export class UmbMediaWorkspaceViewInfoElement extends UmbLitElement {
 			<div class="general-item">
 				<strong><umb-localize key="content_updateDate"></umb-localize></strong>
 				<span>
-					<umb-localize-date .date=${this._updateDate} .options=${TimeOptions}></umb-localize-date>
+					<umb-localize-date .date=${this._updateDate} .options=${UMB_DATE_TIME_FORMAT_OPTIONS}></umb-localize-date>
 				</span>
 			</div>
 		`;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/members/member-type/repository/detail/member-type-detail.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/members/member-type/repository/detail/member-type-detail.server.data-source.ts
index 1944c0603db0..e074348b205a 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/members/member-type/repository/detail/member-type-detail.server.data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/members/member-type/repository/detail/member-type-detail.server.data-source.ts
@@ -40,7 +40,6 @@ export class UmbMemberTypeDetailServerDataSource
 			variesByCulture: false,
 			variesBySegment: false,
 			isElement: false,
-			allowedInLibrary: false,
 			properties: [],
 			containers: [],
 			allowedContentTypes: [],
@@ -104,7 +103,7 @@ export class UmbMemberTypeDetailServerDataSource
 			variesByCulture: model.variesByCulture,
 			variesBySegment: model.variesBySegment,
 			isElement: model.isElement,
-			allowedInLibrary: model.allowedInLibrary,
+			allowedInLibrary: false,
 			properties: model.properties.map((property) => {
 				return {
 					id: property.unique,
@@ -157,7 +156,7 @@ export class UmbMemberTypeDetailServerDataSource
 			variesByCulture: model.variesByCulture,
 			variesBySegment: model.variesBySegment,
 			isElement: model.isElement,
-			allowedInLibrary: model.allowedInLibrary,
+			allowedInLibrary: false,
 			properties: model.properties.map((property) => {
 				return {
 					id: property.unique,
@@ -212,7 +211,6 @@ export class UmbMemberTypeDetailServerDataSource
 			variesByCulture: data.variesByCulture,
 			variesBySegment: data.variesBySegment,
 			isElement: data.isElement,
-			allowedInLibrary: data.allowedInLibrary,
 			properties: data.properties.map((property) => {
 				return {
 					id: property.id,
diff --git a/src/Umbraco.Web.UI.Client/src/packages/property-editors/collection/config/column/components/input-collection-content-type-property.element.ts b/src/Umbraco.Web.UI.Client/src/packages/property-editors/collection/config/column/components/input-collection-content-type-property.element.ts
index 96e96ecfc1d9..fe241a045c7c 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/property-editors/collection/config/column/components/input-collection-content-type-property.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/property-editors/collection/config/column/components/input-collection-content-type-property.element.ts
@@ -1,5 +1,5 @@
 import { html, customElement, property, css } from '@umbraco-cms/backoffice/external/lit';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbChangeEvent, UmbSelectionChangeEvent } from '@umbraco-cms/backoffice/event';
 import { UmbMediaTypeDetailRepository, UMB_MEDIA_TYPE_PICKER_MODAL } from '@umbraco-cms/backoffice/media-type';
@@ -32,7 +32,10 @@ type UmbInputContentTypePropertyConfiguration = {
 };
 
 @customElement('umb-input-collection-content-type-property')
-export class UmbInputCollectionContentTypePropertyElement extends UUIFormControlMixin(UmbLitElement, undefined) {
+export class UmbInputCollectionContentTypePropertyElement extends UUIFormControlWithBasicsMixin(
+	UmbLitElement,
+	undefined,
+) {
 	#configuration: UmbInputContentTypePropertyConfiguration = {
 		documentTypes: {
 			item: {
diff --git a/src/Umbraco.Web.UI.Client/src/packages/property-editors/collection/config/order-by/order-by.element.ts b/src/Umbraco.Web.UI.Client/src/packages/property-editors/collection/config/order-by/order-by.element.ts
index 1d8884cad378..67cf7fab7738 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/property-editors/collection/config/order-by/order-by.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/property-editors/collection/config/order-by/order-by.element.ts
@@ -6,7 +6,7 @@ import type {
 	UmbPropertyEditorConfigCollection,
 	UmbPropertyEditorUiElement,
 } from '@umbraco-cms/backoffice/property-editor';
-import type { UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 
 /**
@@ -20,7 +20,7 @@ export class UmbPropertyEditorUICollectionOrderByElement extends UmbLitElement i
 	public config?: UmbPropertyEditorConfigCollection;
 
 	@state()
-	private _options: Array<Option> = [];
+	private _options: Array<UUISelectOption> = [];
 
 	constructor() {
 		super();
diff --git a/src/Umbraco.Web.UI.Client/src/packages/property-editors/content-picker/config/source-content/input-content-picker-source.element.ts b/src/Umbraco.Web.UI.Client/src/packages/property-editors/content-picker/config/source-content/input-content-picker-source.element.ts
index ce42a1c62831..59ec285a85fd 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/property-editors/content-picker/config/source-content/input-content-picker-source.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/property-editors/content-picker/config/source-content/input-content-picker-source.element.ts
@@ -1,15 +1,15 @@
 import type { UmbContentPickerDynamicRoot, UmbContentPickerSourceType } from '../../types.js';
 import type { UmbInputContentPickerDocumentRootElement } from '../../dynamic-root/components/input-content-picker-document-root.element.js';
 import { html, customElement, property, css, state, nothing } from '@umbraco-cms/backoffice/external/lit';
-import type { UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 
 import '../../dynamic-root/components/input-content-picker-document-root.element.js';
 
 @customElement('umb-input-content-picker-source')
-export class UmbInputContentPickerSourceElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbInputContentPickerSourceElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	protected override getFormElement() {
 		return undefined;
 	}
@@ -43,7 +43,7 @@ export class UmbInputContentPickerSourceElement extends UUIFormControlMixin(UmbL
 	dynamicRoot?: UmbContentPickerDynamicRoot;
 
 	@state()
-	private _options: Array<Option> = [
+	private _options: Array<UUISelectOption> = [
 		{ value: 'content', name: 'Content' },
 		{ value: 'media', name: 'Media' },
 		{ value: 'member', name: 'Members' },
diff --git a/src/Umbraco.Web.UI.Client/src/packages/property-editors/dropdown/property-editor-ui-dropdown.element.ts b/src/Umbraco.Web.UI.Client/src/packages/property-editors/dropdown/property-editor-ui-dropdown.element.ts
index 562258516646..9ff732245680 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/property-editors/dropdown/property-editor-ui-dropdown.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/property-editors/dropdown/property-editor-ui-dropdown.element.ts
@@ -3,7 +3,7 @@ import { css, customElement, html, map, nothing, property, state, when } from '@
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UMB_VALIDATION_EMPTY_LOCALIZATION_KEY, UmbFormControlMixin } from '@umbraco-cms/backoffice/validation';
-import { UUISelectElement } from '@umbraco-cms/backoffice/external/uui';
+import { UUISelectElement, type UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 import type {
 	UmbPropertyEditorConfigCollection,
 	UmbPropertyEditorUiElement,
@@ -27,7 +27,7 @@ export class UmbPropertyEditorUIDropdownElement
 	private _multiple: boolean = false;
 
 	@state()
-	private _options: Array<Option & { invalid?: boolean }> = [];
+	private _options: Array<UUISelectOption & { invalid?: boolean }> = [];
 
 	@property({ type: Array })
 	public override set value(value: Array<string> | string | undefined) {
diff --git a/src/Umbraco.Web.UI.Client/src/packages/property-editors/overlay-size/property-editor-ui-overlay-size.element.ts b/src/Umbraco.Web.UI.Client/src/packages/property-editors/overlay-size/property-editor-ui-overlay-size.element.ts
index d67c4dae0c44..47ecff77418a 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/property-editors/overlay-size/property-editor-ui-overlay-size.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/property-editors/overlay-size/property-editor-ui-overlay-size.element.ts
@@ -4,7 +4,7 @@ import type {
 	UmbPropertyEditorConfigCollection,
 } from '@umbraco-cms/backoffice/property-editor';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import type { UUIModalSidebarSize, UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUIModalSidebarSize, UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 
 /**
@@ -15,9 +15,8 @@ export class UmbPropertyEditorUIOverlaySizeElement extends UmbLitElement impleme
 	@property()
 	value: UUIModalSidebarSize | string = '';
 
-	// TODO: Stop having global type of the UUI-SELECT element. And make it possible to have undefined as an option.
 	@state()
-	private _list: Array<Option> = [
+	private _list: Array<UUISelectOption> = [
 		{ value: undefined as any, name: 'Default', selected: true },
 		{ value: 'small', name: 'Small' },
 		{ value: 'medium', name: 'Medium' },
diff --git a/src/Umbraco.Web.UI.Client/src/packages/property-editors/select/property-editor-ui-select.element.ts b/src/Umbraco.Web.UI.Client/src/packages/property-editors/select/property-editor-ui-select.element.ts
index b4ae7c29a98e..143a4b56c72c 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/property-editors/select/property-editor-ui-select.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/property-editors/select/property-editor-ui-select.element.ts
@@ -5,7 +5,7 @@ import type {
 	UmbPropertyEditorConfigCollection,
 	UmbPropertyEditorUiElement,
 } from '@umbraco-cms/backoffice/property-editor';
-import type { UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 
 /**
@@ -39,7 +39,7 @@ export class UmbPropertyEditorUISelectElement extends UmbLitElement implements U
 	}
 
 	@state()
-	private _options: Array<Option> = [];
+	private _options: Array<UUISelectOption> = [];
 
 	#onChange(event: UUISelectEvent) {
 		this.value = event.target.value as string;
diff --git a/src/Umbraco.Web.UI.Client/src/packages/property-editors/value-type/property-editor-ui-value-type.element.ts b/src/Umbraco.Web.UI.Client/src/packages/property-editors/value-type/property-editor-ui-value-type.element.ts
index 49dd5b24553c..a124b1389474 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/property-editors/value-type/property-editor-ui-value-type.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/property-editors/value-type/property-editor-ui-value-type.element.ts
@@ -1,5 +1,5 @@
 import { html, customElement, property, state, query } from '@umbraco-cms/backoffice/external/lit';
-import type { UUISelectElement, UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectElement, UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 import type {
 	UmbPropertyEditorUiElement,
 	UmbPropertyEditorConfigCollection,
@@ -14,10 +14,8 @@ import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 @customElement('umb-property-editor-ui-value-type')
 export class UmbPropertyEditorUIValueTypeElement extends UmbLitElement implements UmbPropertyEditorUiElement {
 	private _value: string | undefined = undefined;
+
 	@property()
-	public get value(): string | undefined {
-		return this._value;
-	}
 	public set value(value: string | undefined) {
 		this._value = value;
 
@@ -29,12 +27,15 @@ export class UmbPropertyEditorUIValueTypeElement extends UmbLitElement implement
 			this._options[0].selected = true;
 		}
 	}
+	public get value(): string | undefined {
+		return this._value;
+	}
 
 	@query('uui-select')
 	selectEl?: UUISelectElement;
 
 	@state()
-	private _options: Array<Option> = [
+	private _options: Array<UUISelectOption> = [
 		{ name: 'String', value: 'STRING' },
 		{ name: 'Decimal', value: 'DECIMAL' },
 		{ name: 'Date/Time', value: 'DATETIME' },
diff --git a/src/Umbraco.Web.UI.Client/src/packages/rte/Umbraco.RichText.ts b/src/Umbraco.Web.UI.Client/src/packages/rte/Umbraco.RichText.ts
index f785355238a7..f2b7cd2b07ce 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/rte/Umbraco.RichText.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/rte/Umbraco.RichText.ts
@@ -23,6 +23,13 @@ export const manifest: ManifestPropertyEditorSchema = {
 					config: [{ alias: 'validationLimit', value: { min: 0, max: 1 } }],
 					weight: 90,
 				},
+				{
+					alias: 'allowedMediaTypes',
+					label: '#rte_config_allowedMediaTypes',
+					description: '{#rte_config_allowedMediaTypes_description}',
+					propertyEditorUiAlias: 'Umb.PropertyEditorUi.MediaTypePicker',
+					weight: 91,
+				},
 				{
 					alias: 'ignoreUserStartNodes',
 					label: '#rte_config_ignoreUserStartNodes',
diff --git a/src/Umbraco.Web.UI.Client/src/packages/tags/components/tags-input/tags-input.element.ts b/src/Umbraco.Web.UI.Client/src/packages/tags/components/tags-input/tags-input.element.ts
index b84e527e9c9d..8d0161501e75 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/tags/components/tags-input/tags-input.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/tags/components/tags-input/tags-input.element.ts
@@ -12,12 +12,12 @@ import {
 } from '@umbraco-cms/backoffice/external/lit';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import type { TagResponseModel } from '@umbraco-cms/backoffice/external/backend-api';
 import type { UUIInputElement, UUIInputEvent, UUITagElement } from '@umbraco-cms/backoffice/external/uui';
 
 @customElement('umb-tags-input')
-export class UmbTagsInputElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbTagsInputElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	@property({ type: String })
 	group?: string;
 
diff --git a/src/Umbraco.Web.UI.Client/src/packages/templating/partial-views/tree/tree-item-children/collection/action/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/templating/partial-views/tree/tree-item-children/collection/action/manifests.ts
index 7d83e090cb42..6059949f981f 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/templating/partial-views/tree/tree-item-children/collection/action/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/templating/partial-views/tree/tree-item-children/collection/action/manifests.ts
@@ -1,5 +1,6 @@
 import { UMB_PARTIAL_VIEW_TREE_ITEM_CHILDREN_COLLECTION_ALIAS } from '../constants.js';
 import { UMB_COLLECTION_ALIAS_CONDITION } from '@umbraco-cms/backoffice/collection';
+import { UMB_IS_SERVER_PRODUCTION_MODE_CONDITION_ALIAS } from '@umbraco-cms/backoffice/server';
 
 export const manifests: Array<UmbExtensionManifest> = [
 	{
@@ -7,6 +8,15 @@ export const manifests: Array<UmbExtensionManifest> = [
 		kind: 'create',
 		name: 'Partial View Tree Item Children Collection Create Action',
 		alias: 'Umb.CollectionAction.PartialViewTreeItemChildren.Create',
-		conditions: [{ alias: UMB_COLLECTION_ALIAS_CONDITION, match: UMB_PARTIAL_VIEW_TREE_ITEM_CHILDREN_COLLECTION_ALIAS }],
+		conditions: [
+			{
+				alias: UMB_COLLECTION_ALIAS_CONDITION,
+				match: UMB_PARTIAL_VIEW_TREE_ITEM_CHILDREN_COLLECTION_ALIAS,
+			},
+			{
+				alias: UMB_IS_SERVER_PRODUCTION_MODE_CONDITION_ALIAS,
+				match: false,
+			},
+		],
 	},
 ];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/templating/stylesheets/global-components/stylesheet-input/stylesheet-input.element.ts b/src/Umbraco.Web.UI.Client/src/packages/templating/stylesheets/global-components/stylesheet-input/stylesheet-input.element.ts
index 30f0bc5b21e5..76c965919501 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/templating/stylesheets/global-components/stylesheet-input/stylesheet-input.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/templating/stylesheets/global-components/stylesheet-input/stylesheet-input.element.ts
@@ -1,12 +1,12 @@
 import type { UmbStylesheetItemModel } from '../../types.js';
 import { UmbStylesheetPickerInputContext } from './stylesheet-input.context.js';
 import { css, html, customElement, property, state, repeat } from '@umbraco-cms/backoffice/external/lit';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { splitStringToArray } from '@umbraco-cms/backoffice/utils';
 
 @customElement('umb-stylesheet-input')
-export class UmbStylesheetInputElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbStylesheetInputElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	/**
 	 * This is a minimum amount of selected items in this input.
 	 * @type {number}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/templating/templates/global-components/input-template/input-template.element.ts b/src/Umbraco.Web.UI.Client/src/packages/templating/templates/global-components/input-template/input-template.element.ts
index 03a1dba4412f..ebcf72a11fa4 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/templating/templates/global-components/input-template/input-template.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/templating/templates/global-components/input-template/input-template.element.ts
@@ -4,7 +4,7 @@ import type { UmbTemplateItemModel } from '../../repository/item/index.js';
 import { UmbTemplateItemRepository } from '../../repository/item/index.js';
 import { UMB_TEMPLATE_PICKER_MODAL } from '../../modals/index.js';
 import { css, html, customElement, property, state } from '@umbraco-cms/backoffice/external/lit';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import { umbOpenModal } from '@umbraco-cms/backoffice/modal';
 import { UMB_WORKSPACE_MODAL } from '@umbraco-cms/backoffice/workspace';
 import { UmbModalRouteRegistrationController } from '@umbraco-cms/backoffice/router';
@@ -12,7 +12,7 @@ import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbChangeEvent } from '@umbraco-cms/backoffice/event';
 
 @customElement('umb-input-template')
-export class UmbInputTemplateElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbInputTemplateElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	/**
 	 * This is a minimum amount of selected items in this input.
 	 * @type {number}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/templating/templates/global-components/template-card/template-card.element.ts b/src/Umbraco.Web.UI.Client/src/packages/templating/templates/global-components/template-card/template-card.element.ts
index 3fbcc03cff20..ae04353a91c2 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/templating/templates/global-components/template-card/template-card.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/templating/templates/global-components/template-card/template-card.element.ts
@@ -1,5 +1,5 @@
 import { css, html, customElement, property } from '@umbraco-cms/backoffice/external/lit';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 
 /**
@@ -11,7 +11,7 @@ import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 // TODO: This should extends the UUICardElement, and the visual look of this should be like the UserCard or similarly.
 // TOOD: Consider if this should be select in the 'persisted'-select style when it is selected as a default. (But its should not use the runtime-selection style)
 @customElement('umb-template-card')
-export class UmbTemplateCardElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbTemplateCardElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	@property({ type: String })
 	override name = '';
 
diff --git a/src/Umbraco.Web.UI.Client/src/packages/templating/templates/tree/tree-item-children/collection/action/manifests.ts b/src/Umbraco.Web.UI.Client/src/packages/templating/templates/tree/tree-item-children/collection/action/manifests.ts
index 843420f79829..128b8ba8a651 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/templating/templates/tree/tree-item-children/collection/action/manifests.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/templating/templates/tree/tree-item-children/collection/action/manifests.ts
@@ -1,5 +1,6 @@
 import { UMB_TEMPLATE_TREE_ITEM_CHILDREN_COLLECTION_ALIAS } from '../constants.js';
 import { UMB_COLLECTION_ALIAS_CONDITION } from '@umbraco-cms/backoffice/collection';
+import { UMB_IS_SERVER_PRODUCTION_MODE_CONDITION_ALIAS } from '@umbraco-cms/backoffice/server';
 
 export const manifests: Array<UmbExtensionManifest> = [
 	{
@@ -7,6 +8,15 @@ export const manifests: Array<UmbExtensionManifest> = [
 		kind: 'create',
 		name: 'Template Tree Item Children Collection Create Action',
 		alias: 'Umb.CollectionAction.TemplateTreeItemChildren.Create',
-		conditions: [{ alias: UMB_COLLECTION_ALIAS_CONDITION, match: UMB_TEMPLATE_TREE_ITEM_CHILDREN_COLLECTION_ALIAS }],
+		conditions: [
+			{
+				alias: UMB_COLLECTION_ALIAS_CONDITION,
+				match: UMB_TEMPLATE_TREE_ITEM_CHILDREN_COLLECTION_ALIAS,
+			},
+			{
+				alias: UMB_IS_SERVER_PRODUCTION_MODE_CONDITION_ALIAS,
+				match: false,
+			},
+		],
 	},
 ];
diff --git a/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/embedded-media/embedded-media.tiptap-extension.ts b/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/embedded-media/embedded-media.tiptap-extension.ts
index f7e981ad4fb2..23b900fa66f3 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/embedded-media/embedded-media.tiptap-extension.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/embedded-media/embedded-media.tiptap-extension.ts
@@ -20,7 +20,7 @@ export const umbEmbeddedMedia = Node.create<UmbEmbeddedMediaOptions>({
 
 	addAttributes() {
 		return {
-			'data-embed-constrain': { default: false },
+			'data-embed-constrain': { default: true },
 			'data-embed-height': { default: 240 },
 			'data-embed-url': { default: null },
 			'data-embed-width': { default: 360 },
diff --git a/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/embedded-media/embedded-media.tiptap-toolbar-api.ts b/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/embedded-media/embedded-media.tiptap-toolbar-api.ts
index dd463516dcf6..0cdad8acdb50 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/embedded-media/embedded-media.tiptap-toolbar-api.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/embedded-media/embedded-media.tiptap-toolbar-api.ts
@@ -6,10 +6,8 @@ import { umbOpenModal } from '@umbraco-cms/backoffice/modal';
 
 export default class UmbTiptapToolbarEmbeddedMediaExtensionApi extends UmbTiptapToolbarElementApiBase {
 	override async execute(editor?: Editor) {
-		const data = {
-			constrain: false,
-			height: 240,
-			width: 360,
+		const data: Record<string, unknown> = {
+			constrain: true,
 			url: '',
 		};
 
diff --git a/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/media-picker/media-picker.tiptap-toolbar-api.ts b/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/media-picker/media-picker.tiptap-toolbar-api.ts
index 2de61bc23933..1f0a7a8a2d04 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/media-picker/media-picker.tiptap-toolbar-api.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/media-picker/media-picker.tiptap-toolbar-api.ts
@@ -1,7 +1,7 @@
-import type { Editor, ProseMirrorNode } from '../../externals.js';
+import type { Editor } from '../../externals.js';
 import { NodeSelection } from '../../externals.js';
 import { UmbTiptapToolbarElementApiBase } from '../tiptap-toolbar-element-api-base.js';
-import { getGuidFromUdi, imageSize } from '@umbraco-cms/backoffice/utils';
+import { getGuidFromUdi, splitStringToArray } from '@umbraco-cms/backoffice/utils';
 import { ImageCropModeModel } from '@umbraco-cms/backoffice/external/backend-api';
 import { UmbImagingRepository } from '@umbraco-cms/backoffice/imaging';
 import { UMB_MEDIA_CAPTION_ALT_TEXT_MODAL, UMB_MEDIA_PICKER_MODAL } from '@umbraco-cms/backoffice/media';
@@ -28,6 +28,10 @@ export default class UmbTiptapToolbarMediaPickerToolbarExtensionApi extends UmbT
 	 */
 	maxWidth = this.maxImageSize;
 
+	get #allowedMediaTypeIds(): Array<string> {
+		return splitStringToArray(this.configuration?.getValueByAlias<string>('allowedMediaTypes'));
+	}
+
 	constructor(host: UmbControllerHost) {
 		super(host);
 
@@ -41,24 +45,35 @@ export default class UmbTiptapToolbarMediaPickerToolbarExtensionApi extends UmbT
 	}
 
 	override async execute(editor: Editor) {
-		const currentTarget = editor.getAttributes('image');
-		const currentMediaUdi = this.#extractMediaUdi(currentTarget);
-		const currentAltText = currentTarget?.alt;
-		const currentCaption = this.#extractCaption(editor.state.selection);
-
-		await this.#updateImageWithMetadata(editor, currentMediaUdi, currentAltText, currentCaption);
-	}
+		let currentTarget = editor.getAttributes('image');
+		let currentMediaUdi = this.#extractMediaUdi(currentTarget);
+		let currentCaption: string | undefined;
+
+		// If no image found directly, check if cursor is inside a figure (e.g. in figcaption)
+		if (!currentMediaUdi) {
+			const figureData = this.#extractFigureImageData(editor);
+			if (figureData) {
+				currentTarget = figureData.imageAttrs;
+				currentMediaUdi = this.#extractMediaUdi(currentTarget);
+				currentCaption = figureData.caption;
+				// Select the figure so insertContent replaces it instead of inserting at cursor
+				editor.commands.setNodeSelection(figureData.pos);
+			}
+		} else {
+			currentCaption = this.#extractCaption(editor.state.selection);
+		}
 
-	async #updateImageWithMetadata(
-		editor: Editor,
-		currentMediaUdi: string | undefined,
-		currentAltText: string | undefined,
-		currentCaption: string | undefined,
-	) {
-		const mediaGuid = await this.#getMediaGuid(currentMediaUdi);
+		// If editing existing image, use its UDI; otherwise open media picker
+		const mediaGuid = currentMediaUdi ?? (await this.#openMediaPicker());
 		if (!mediaGuid) return;
 
-		const media = await this.#showMediaCaptionAltText(mediaGuid, currentAltText, currentCaption);
+		const media = await this.#showMediaCaptionAltText(
+			mediaGuid,
+			currentTarget?.alt as string | undefined,
+			currentCaption,
+			currentTarget?.width ? parseInt(currentTarget.width as string, 10) : undefined,
+			currentTarget?.height ? parseInt(currentTarget.height as string, 10) : undefined,
+		);
 		if (!media) return;
 
 		this.#insertInEditor(editor, mediaGuid, media);
@@ -72,79 +87,90 @@ export default class UmbTiptapToolbarMediaPickerToolbarExtensionApi extends UmbT
 		if (!(selection instanceof NodeSelection)) return undefined;
 		if (selection.node.type.name !== 'figure') return undefined;
 
-		return this.#findFigcaptionText(selection.node);
-	}
-
-	#findFigcaptionText(figureNode: ProseMirrorNode): string | undefined {
 		let caption: string | undefined;
-		figureNode.descendants((child) => {
+		selection.node.descendants((child) => {
 			if (child.type.name === 'figcaption') {
 				caption = child.textContent || undefined;
-				return false; // Stop searching
+				return false;
 			}
-			return true; // Continue searching
+			return true;
 		});
 		return caption;
 	}
 
-	async #getMediaGuid(currentMediaUdi?: string): Promise<string | undefined> {
-		if (currentMediaUdi) {
-			// Image already exists, go directly to edit alt text/caption
-			return currentMediaUdi;
-		}
-
-		// No image selected, open media picker
-		const selection = await this.#openMediaPicker();
-		if (!selection?.length) return undefined;
-
-		const selectedGuid = selection[0];
-		if (!selectedGuid) {
-			throw new Error('No media selected');
+	#extractFigureImageData(
+		editor: Editor,
+	): { imageAttrs: Record<string, unknown>; caption?: string; pos: number } | undefined {
+		const { $from } = editor.state.selection;
+
+		for (let depth = $from.depth; depth >= 0; depth--) {
+			const node = $from.node(depth);
+			if (node.type.name === 'figure') {
+				let imageAttrs: Record<string, unknown> = {};
+				let caption: string | undefined;
+
+				node.descendants((child) => {
+					if (child.type.name === 'image') {
+						imageAttrs = { ...child.attrs };
+						return false;
+					}
+					if (child.type.name === 'figcaption') {
+						caption = child.textContent || undefined;
+						return false;
+					}
+					return true;
+				});
+
+				if (imageAttrs['data-udi']) {
+					return { imageAttrs, caption, pos: $from.before(depth) };
+				}
+			}
 		}
 
-		return selectedGuid;
+		return undefined;
 	}
 
-	async #openMediaPicker(currentMediaUdi?: string) {
+	async #openMediaPicker(currentMediaUdi?: string): Promise<string | undefined> {
+		const allowedIds = this.#allowedMediaTypeIds;
 		const modalHandler = this.#modalManager?.open(this, UMB_MEDIA_PICKER_MODAL, {
 			data: {
 				multiple: false,
-				//startNodeIsVirtual,
+				pickableFilter: allowedIds.length ? (item) => allowedIds.includes(item.mediaType.unique) : undefined,
 			},
 			value: {
 				selection: currentMediaUdi ? [currentMediaUdi] : [],
 			},
 		});
-
-		if (!modalHandler) return;
+		if (!modalHandler) return undefined;
 
 		const { selection } = await modalHandler.onSubmit().catch(() => ({ selection: undefined }));
-
-		return selection;
+		return selection?.[0] ?? undefined;
 	}
 
-	async #showMediaCaptionAltText(mediaUnique: string, altText?: string, caption?: string) {
+	async #showMediaCaptionAltText(
+		mediaUnique: string,
+		altText?: string,
+		caption?: string,
+		width?: number,
+		height?: number,
+	) {
 		const modalHandler = this.#modalManager?.open(this, UMB_MEDIA_CAPTION_ALT_TEXT_MODAL, {
-			data: { mediaUnique },
-			value: {
-				url: '',
-				altText,
-				caption,
-			},
+			data: { mediaUnique, maxImageSize: this.maxImageSize },
+			value: { url: '', altText, caption, width, height },
+			modal: { size: 'medium' }, // Override default sidebar size for better UX
 		});
-		const mediaData = await modalHandler?.onSubmit().catch(() => null);
-		return mediaData;
+		return modalHandler?.onSubmit().catch(() => undefined);
 	}
 
 	async #insertInEditor(editor: Editor, mediaUnique: string, media: UmbMediaCaptionAltTextModalValue) {
 		if (!media?.url) return;
 
-		const maxImageSize = this.maxImageSize;
+		const width = media.width || this.maxImageSize;
+		const height = media.height || this.maxImageSize;
 
-		// Get the resized image URL
 		const { data } = await this.#imagingRepository.requestResizedItems([mediaUnique], {
-			width: maxImageSize,
-			height: maxImageSize,
+			width,
+			height,
 			mode: ImageCropModeModel.MAX,
 		});
 
@@ -153,14 +179,8 @@ export default class UmbTiptapToolbarMediaPickerToolbarExtensionApi extends UmbT
 			return;
 		}
 
-		// Set the media URL to the first item in the data array
-		const src = data[0].url;
-
-		// Fetch the actual image dimensions
-		const { width, height } = await imageSize(src);
-
 		const img = {
-			src,
+			src: data[0].url,
 			alt: media.altText,
 			'data-udi': `umb://media/${mediaUnique.replace(/-/g, '')}`,
 			width: width.toString(),
@@ -171,24 +191,8 @@ export default class UmbTiptapToolbarMediaPickerToolbarExtensionApi extends UmbT
 			return editor.commands.insertContent({
 				type: 'figure',
 				content: [
-					{
-						type: 'paragraph',
-						content: [
-							{
-								type: 'image',
-								attrs: img,
-							},
-						],
-					},
-					{
-						type: 'figcaption',
-						content: [
-							{
-								type: 'text',
-								text: media.caption,
-							},
-						],
-					},
+					{ type: 'paragraph', content: [{ type: 'image', attrs: img }] },
+					{ type: 'figcaption', content: [{ type: 'text', text: media.caption }] },
 				],
 			});
 		}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/media-upload/media-upload.tiptap-api.ts b/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/media-upload/media-upload.tiptap-api.ts
index 47c940f253d7..5b7d095ceb14 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/media-upload/media-upload.tiptap-api.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/tiptap/extensions/media-upload/media-upload.tiptap-api.ts
@@ -2,11 +2,14 @@ import { Extension } from '../../externals.js';
 import { UmbTiptapExtensionApiBase } from '../tiptap-extension-api-base.js';
 import type { Editor } from '../../externals.js';
 import type { UmbTiptapExtensionArgs } from '../types.js';
-import { imageSize } from '@umbraco-cms/backoffice/utils';
+import { getFileExtension, imageSize, splitStringToArray } from '@umbraco-cms/backoffice/utils';
 import { TemporaryFileStatus, UmbTemporaryFileManager } from '@umbraco-cms/backoffice/temporary-file';
 import { UmbId } from '@umbraco-cms/backoffice/id';
 import { UmbLocalizationController } from '@umbraco-cms/backoffice/localization-api';
 import { UMB_NOTIFICATION_CONTEXT } from '@umbraco-cms/backoffice/notification';
+import { UMB_DROPZONE_MEDIA_TYPE_PICKER_MODAL } from '@umbraco-cms/backoffice/media';
+import { umbOpenModal } from '@umbraco-cms/backoffice/modal';
+import { UmbMediaTypeStructureRepository, type UmbAllowedMediaTypeModel } from '@umbraco-cms/backoffice/media-type';
 import type { UmbControllerHost } from '@umbraco-cms/backoffice/controller-api';
 import type { UmbPropertyEditorConfigCollection } from '@umbraco-cms/backoffice/property-editor';
 import type { UmbTemporaryFileModel } from '@umbraco-cms/backoffice/temporary-file';
@@ -33,12 +36,25 @@ export default class UmbTiptapMediaUploadExtensionApi extends UmbTiptapExtension
 	 */
 	get allowedFileTypes(): string[] {
 		return (
-			this.#configuration?.getValueByAlias<string[]>('allowedFileTypes') ?? ['image/jpeg', 'image/png', 'image/gif']
+			this.#configuration?.getValueByAlias<string[]>('allowedFileTypes') ?? [
+				'image/jpeg',
+				'image/png',
+				'image/gif',
+				'image/webp',
+				'image/svg+xml',
+				'image/avif',
+			]
 		);
 	}
 
+	get #allowedMediaTypeIds(): Array<string> {
+		return splitStringToArray(this.#configuration?.getValueByAlias<string>('allowedMediaTypes'));
+	}
+
 	readonly #manager = new UmbTemporaryFileManager(this);
 	readonly #localize = new UmbLocalizationController(this);
+	readonly #mediaTypeStructure = new UmbMediaTypeStructureRepository(this);
+	readonly #mediaTypeCache = new Map<string, Array<UmbAllowedMediaTypeModel>>();
 	#notificationContext?: typeof UMB_NOTIFICATION_CONTEXT.TYPE;
 
 	constructor(host: UmbControllerHost) {
@@ -98,26 +114,29 @@ export default class UmbTiptapMediaUploadExtensionApi extends UmbTiptapExtension
 	 * @param {Editor} editor The editor to insert the images into.
 	 */
 	async #uploadTemporaryFile(files: FileList, editor: Editor): Promise<void> {
-		const filteredFiles = this.#filterFiles(files);
-		const fileModels = filteredFiles.map((file) => this.#mapFileToTemporaryFile(file));
-
-		this.dispatchEvent(new CustomEvent('rte.file.uploading', { composed: true, bubbles: true, detail: fileModels }));
-
-		const uploads = await this.#manager.upload(fileModels);
-		const maxImageSize = this.maxImageSize;
-
-		uploads.forEach(async (upload) => {
-			if (upload.status !== TemporaryFileStatus.SUCCESS) {
-				this.#notificationContext?.peek('danger', {
-					data: {
-						headline: upload.file.name,
-						message: this.#localize.term('errors_dissallowedMediaType'),
-					},
-				});
-				return;
+		const { allowed, rejected } = this.#filterFiles(files);
+
+		for (const file of rejected) {
+			this.#showDisallowedNotification(file.name);
+		}
+
+		for (const file of allowed) {
+			const isAllowed = await this.#validateMediaType(file);
+			if (!isAllowed) continue;
+
+			const fileModel = this.#mapFileToTemporaryFile(file);
+
+			this.dispatchEvent(new CustomEvent('rte.file.uploading', { composed: true, bubbles: true, detail: [fileModel] }));
+
+			const uploads = await this.#manager.upload([fileModel]);
+			const upload = uploads[0];
+
+			if (!upload || upload.status !== TemporaryFileStatus.SUCCESS) {
+				continue;
 			}
 
 			const blobUrl = URL.createObjectURL(upload.file);
+			const maxImageSize = this.maxImageSize;
 
 			// Get the image dimensions - this essentially simulates what the server would do
 			// when it resizes the image. The server will return the resized image URL.
@@ -134,9 +153,84 @@ export default class UmbTiptapMediaUploadExtensionApi extends UmbTiptapExtension
 					'data-tmpimg': upload.temporaryUnique,
 				})
 				.run();
-		});
 
-		this.dispatchEvent(new CustomEvent('rte.file.uploaded', { composed: true, bubbles: true, detail: uploads }));
+			this.dispatchEvent(new CustomEvent('rte.file.uploaded', { composed: true, bubbles: true, detail: [upload] }));
+		}
+	}
+
+	/**
+	 * Validates a file against the allowed media types configuration.
+	 * Uses the media type structure repository to check which media types support the file extension,
+	 * then intersects with the configured allowedMediaTypes. Shows a type picker modal when ambiguous.
+	 * @param {File} file The file to validate.
+	 * @returns {boolean} Whether the file is allowed.
+	 */
+	async #validateMediaType(file: File): Promise<boolean> {
+		const allowedIds = this.#allowedMediaTypeIds;
+		if (!allowedIds.length) return true;
+
+		const extension = getFileExtension(file.name)?.toLowerCase();
+		if (!extension) {
+			this.#showDisallowedNotification(file.name);
+			return false;
+		}
+
+		const availableMediaTypes = await this.#getAvailableMediaTypesOf(extension);
+		if (!availableMediaTypes.length) {
+			this.#showDisallowedNotification(file.name);
+			return false;
+		}
+
+		// Intersect available media types with the configured allowed types
+		const options = availableMediaTypes.filter((type) => type.unique && allowedIds.includes(type.unique));
+
+		if (!options.length) {
+			this.#showDisallowedNotification(file.name);
+			return false;
+		}
+
+		if (options.length === 1) return true;
+
+		// Multiple matches — prefer specific extension matches over fallbacks
+		const specificMatches = options.filter((x) => x.matchedFileExtension === true);
+
+		if (specificMatches.length === 1) return true;
+
+		if (specificMatches.length > 1) {
+			// Multiple specific matches — let the user pick
+			return await this.#showMediaTypePicker(specificMatches);
+		}
+
+		// All fallbacks — auto-select
+		return true;
+	}
+
+	async #getAvailableMediaTypesOf(extension: string): Promise<Array<UmbAllowedMediaTypeModel>> {
+		const cached = this.#mediaTypeCache.get(extension);
+		if (cached) return cached;
+
+		try {
+			const result = await this.#mediaTypeStructure.requestMediaTypesOf({ fileExtension: extension });
+			this.#mediaTypeCache.set(extension, result);
+			return result;
+		} catch {
+			return [];
+		}
+	}
+
+	async #showMediaTypePicker(options: Array<UmbAllowedMediaTypeModel>): Promise<boolean> {
+		return umbOpenModal(this, UMB_DROPZONE_MEDIA_TYPE_PICKER_MODAL, { data: { options } }).then(
+			() => true,
+			() => false,
+		);
+	}
+
+	#showDisallowedNotification(fileName: string) {
+		this.#notificationContext?.peek('warning', {
+			data: {
+				message: `${this.#localize.term('media_disallowedFileType')} (${fileName})`,
+			},
+		});
 	}
 
 	#mapFileToTemporaryFile(file: File): UmbTemporaryFileModel {
@@ -146,7 +240,12 @@ export default class UmbTiptapMediaUploadExtensionApi extends UmbTiptapExtension
 		};
 	}
 
-	#filterFiles(files: FileList): File[] {
-		return Array.from(files).filter((file) => this.allowedFileTypes.includes(file.type));
+	#filterFiles(files: FileList): { allowed: File[]; rejected: File[] } {
+		const allowed: File[] = [];
+		const rejected: File[] = [];
+		for (const file of files) {
+			(this.allowedFileTypes.includes(file.type) ? allowed : rejected).push(file);
+		}
+		return { allowed, rejected };
 	}
 }
diff --git a/src/Umbraco.Web.UI.Client/src/packages/user/current-user/current-user-header-app.element.ts b/src/Umbraco.Web.UI.Client/src/packages/user/current-user/current-user-header-app.element.ts
index 3e35f55e2700..3ca92269d809 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/user/current-user/current-user-header-app.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/user/current-user/current-user-header-app.element.ts
@@ -1,6 +1,7 @@
 import { UMB_CURRENT_USER_MODAL } from './modals/current-user/current-user-modal.token.js';
 import type { UmbCurrentUserModel } from './types.js';
 import { UMB_CURRENT_USER_CONTEXT } from './constants.js';
+import { getInitials } from './utils/index.js';
 import { css, html, customElement, state } from '@umbraco-cms/backoffice/external/lit';
 import { umbOpenModal } from '@umbraco-cms/backoffice/modal';
 import { UmbHeaderAppButtonElement } from '@umbraco-cms/backoffice/components';
@@ -38,11 +39,16 @@ export class UmbCurrentUserHeaderAppElement extends UmbHeaderAppButtonElement {
 	}
 
 	override render() {
+		const userInitials = this._currentUser?.name ? getInitials(this._currentUser.name) : '';
+		const accessibleLabel = this._currentUser?.name
+			? this.localize.term('visuallyHiddenTexts_profileOptions', this._currentUser.name, userInitials)
+			: this.localize.term('visuallyHiddenTexts_profileOptionsDefault');
+
 		return html`
 			<uui-button
 				@click=${this.#handleUserClick}
 				look="primary"
-				label=${this.localize.term('visuallyHiddenTexts_profileOptions')}
+				label=${accessibleLabel}
 				compact>
 				<umb-user-avatar
 					id="Avatar"
diff --git a/src/Umbraco.Web.UI.Client/src/packages/user/current-user/theme/current-user-theme-user-profile-app.element.ts b/src/Umbraco.Web.UI.Client/src/packages/user/current-user/theme/current-user-theme-user-profile-app.element.ts
index 1e748750aa25..0153aaad0f15 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/user/current-user/theme/current-user-theme-user-profile-app.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/user/current-user/theme/current-user-theme-user-profile-app.element.ts
@@ -3,7 +3,7 @@ import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { umbExtensionsRegistry } from '@umbraco-cms/backoffice/extension-registry';
 import { UMB_THEME_CONTEXT } from '@umbraco-cms/backoffice/themes';
 import type { UmbThemeContext } from '@umbraco-cms/backoffice/themes';
-import type { UUISelectEvent } from '@umbraco-cms/backoffice/external/uui';
+import type { UUISelectEvent, UUISelectOption } from '@umbraco-cms/backoffice/external/uui';
 
 @customElement('umb-current-user-theme-user-profile-app')
 export class UmbCurrentUserThemeUserProfileAppElement extends UmbLitElement {
@@ -13,7 +13,7 @@ export class UmbCurrentUserThemeUserProfileAppElement extends UmbLitElement {
 	private _themeAlias?: string;
 
 	@state()
-	private _themes: Array<Option> = [];
+	private _themes: Array<UUISelectOption> = [];
 
 	constructor() {
 		super();
diff --git a/src/Umbraco.Web.UI.Client/src/packages/user/current-user/utils/get-initials.function.test.ts b/src/Umbraco.Web.UI.Client/src/packages/user/current-user/utils/get-initials.function.test.ts
new file mode 100644
index 000000000000..75610753eb3f
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/user/current-user/utils/get-initials.function.test.ts
@@ -0,0 +1,66 @@
+import { expect } from '@open-wc/testing';
+import { getInitials } from './get-initials.function.js';
+
+
+describe('getInitials', () => {
+	it('should extract first and last initials from a full name', () => {
+		expect(getInitials('Andreas Lykke Borg')).to.equal('AB');
+	});
+
+	it('should extract first and last initials from a two-word name', () => {
+		expect(getInitials('Rick Doesburg')).to.equal('RD');
+	});
+
+	it('should return uppercase initials', () => {
+		expect(getInitials('john doe')).to.equal('JD');
+	});
+
+	it('should handle names with extra whitespace', () => {
+		expect(getInitials('Jane  Mary  Smith')).to.equal('JS');
+	});
+
+	it('should return single initial for single-word names', () => {
+		expect(getInitials('Madonna')).to.equal('M');
+	});
+
+	it('should return empty string for null name', () => {
+		expect(getInitials(null as any)).to.equal('');
+	});
+
+	it('should return empty string for undefined name', () => {
+		expect(getInitials(undefined as any)).to.equal('');
+	});
+
+	it('should return empty string for empty string', () => {
+		expect(getInitials('')).to.equal('');
+	});
+
+	it('should return empty string for whitespace-only string', () => {
+		expect(getInitials('   ')).to.equal('');
+	});
+
+	it('should ignore parenthetical suffixes when generating initials', () => {
+		expect(getInitials('Henrik Christensen (HC)')).to.equal('HC');
+		expect(getInitials('John Doe (Admin)')).to.equal('JD');
+	});
+
+	it('should ignore role descriptions in parentheses', () => {
+		expect(getInitials('Jane Smith (CEO)')).to.equal('JS');
+	});
+
+	it('should handle names with brackets and special characters', () => {
+		expect(getInitials('John [Admin] Doe')).to.equal('JD');
+		expect(getInitials('Alice @Company')).to.equal('A');
+	});
+
+	it('should handle names with only parentheses content', () => {
+		expect(getInitials('(Test)')).to.equal('');
+	});
+
+	it('should support non-latin characters', () => {
+		expect(getInitials('Привет Ša')).to.equal('ПŠ');
+		expect(getInitials('Привет')).to.equal('П');
+		expect(getInitials('åse hylle')).to.equal('ÅH');
+	});
+});
+
diff --git a/src/Umbraco.Web.UI.Client/src/packages/user/current-user/utils/get-initials.function.ts b/src/Umbraco.Web.UI.Client/src/packages/user/current-user/utils/get-initials.function.ts
new file mode 100644
index 000000000000..867243790be2
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/packages/user/current-user/utils/get-initials.function.ts
@@ -0,0 +1,39 @@
+/**
+ * Extracts the first and last initial from a user's name.
+ * Replicates logic from UUI avatar component to ensure consistency.
+ * @param name - The user's full name
+ * @returns The initials in uppercase
+ *
+ * @note This function duplicates similar logic from the UUI avatar component.
+ * It filters out parts beginning with special characters or punctuation to handle
+ * cases like "John Doe (Admin)" correctly, resulting in "JD" instead of "J(".
+ */
+// TODO: When the utility to extract initials is exposed from the UUI library, use it and deprecate this function.
+export function getInitials(name: string): string {
+	let initials = '';
+
+	if (!name) {
+		return initials;
+	}
+
+	// Split by whitespace and filter out parts that start with special characters
+	// This filters out parts beginning with punctuation (like parentheses, brackets, @ symbols)
+	// while keeping parts that start with letters or numbers
+	const nameParts = name
+		.split(/\s+/)
+		.filter(part => part.length > 0 && !/^[^\p{L}\p{N}]/u.test(part));
+
+	if (nameParts.length === 0) {
+		return initials;
+	}
+
+	// Take first character of the first valid name part
+	initials = nameParts[0].charAt(0);
+
+	// If there's more than one valid name part, add the first character of the last valid name part
+	if (nameParts.length > 1) {
+		initials += nameParts.at(-1)!.charAt(0);
+	}
+
+	return initials.toUpperCase();
+}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/user/current-user/utils/index.ts b/src/Umbraco.Web.UI.Client/src/packages/user/current-user/utils/index.ts
index 24abca5b5fdf..feed7c5a62bb 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/user/current-user/utils/index.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/user/current-user/utils/index.ts
@@ -1,2 +1,3 @@
+export * from './get-initials.function.js';
 export * from './is-current-user-an-admin.function.js';
 export * from './is-current-user.function.js';
diff --git a/src/Umbraco.Web.UI.Client/src/packages/user/user-group/components/input-user-group/user-group-input.element.ts b/src/Umbraco.Web.UI.Client/src/packages/user/user-group/components/input-user-group/user-group-input.element.ts
index d86884dc9007..05ece053217f 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/user/user-group/components/input-user-group/user-group-input.element.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/user/user-group/components/input-user-group/user-group-input.element.ts
@@ -15,13 +15,13 @@ import { splitStringToArray } from '@umbraco-cms/backoffice/utils';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
 import { UmbModalRouteRegistrationController } from '@umbraco-cms/backoffice/router';
 import { UMB_WORKSPACE_MODAL } from '@umbraco-cms/backoffice/workspace';
-import { UUIFormControlMixin } from '@umbraco-cms/backoffice/external/uui';
+import { UUIFormControlWithBasicsMixin } from '@umbraco-cms/backoffice/external/uui';
 import type { UmbRepositoryItemsStatus } from '@umbraco-cms/backoffice/repository';
 
 import '@umbraco-cms/backoffice/entity-item';
 
 @customElement('umb-user-group-input')
-export class UmbUserGroupInputElement extends UUIFormControlMixin(UmbLitElement, '') {
+export class UmbUserGroupInputElement extends UUIFormControlWithBasicsMixin(UmbLitElement, '') {
 	/**
 	 * This is a minimum amount of selected items in this input.
 	 * @type {number}
diff --git a/src/Umbraco.Web.UI.Client/src/packages/user/user/repository/change-password/change-user-password.repository.ts b/src/Umbraco.Web.UI.Client/src/packages/user/user/repository/change-password/change-user-password.repository.ts
index 404958ae528e..5effaee8054f 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/user/user/repository/change-password/change-user-password.repository.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/user/user/repository/change-password/change-user-password.repository.ts
@@ -20,6 +20,9 @@ export class UmbChangeUserPasswordRepository extends UmbUserRepositoryBase {
 		if (!error) {
 			const notification = { data: { message: `Password changed` } };
 			this.notificationContext?.peek('positive', notification);
+		} else {
+			const notification = { data: { message: error.message ?? 'Unknown failure' } };
+			this.notificationContext?.peek('danger', notification);
 		}
 
 		return { data, error };
diff --git a/src/Umbraco.Web.UI.Client/src/packages/user/user/repository/change-password/change-user-password.server.data-source.ts b/src/Umbraco.Web.UI.Client/src/packages/user/user/repository/change-password/change-user-password.server.data-source.ts
index 54e04e24b732..1b4a9693f879 100644
--- a/src/Umbraco.Web.UI.Client/src/packages/user/user/repository/change-password/change-user-password.server.data-source.ts
+++ b/src/Umbraco.Web.UI.Client/src/packages/user/user/repository/change-password/change-user-password.server.data-source.ts
@@ -36,6 +36,7 @@ export class UmbChangeUserPasswordServerDataSource {
 					newPassword,
 				},
 			}),
+			{ disableNotifications: true },
 		);
 	}
 }
diff --git a/src/Umbraco.Web.UI.Client/vite.config.ts b/src/Umbraco.Web.UI.Client/vite.config.ts
index cc746ba6a70c..2c5a74b58206 100644
--- a/src/Umbraco.Web.UI.Client/vite.config.ts
+++ b/src/Umbraco.Web.UI.Client/vite.config.ts
@@ -18,11 +18,16 @@ export const plugins: PluginOption[] = [
 				dest: 'umbraco/backoffice/css',
 			},
 			{
-				src: 'node_modules/@umbraco-ui/uui-css/dist/uui-css.css',
+				// UUI theme CSS (dark.css, high-contrast.css, etc.).
+				// This config is used by the dev server and PR preview builds only.
+				// The production build (build:for:cms) copies these files via
+				// src/external/uui/vite.config.ts during the workspace build instead.
+				// Theme manifests referencing these files: src/packages/core/themes/manifests.ts.
+				src: 'node_modules/@umbraco-ui/uui/dist/themes/*',
 				dest: 'umbraco/backoffice/css',
 			},
 			{
-				src: 'node_modules/@umbraco-ui/uui-css/assets/fonts/*',
+				src: 'node_modules/@umbraco-ui/uui/dist/assets/fonts/*',
 				dest: 'umbraco/backoffice/assets/fonts',
 			},
 			{
diff --git a/src/Umbraco.Web.UI.Login/.nvmrc b/src/Umbraco.Web.UI.Login/.nvmrc
index 2bd5a0a98a36..a45fd52cc589 100644
--- a/src/Umbraco.Web.UI.Login/.nvmrc
+++ b/src/Umbraco.Web.UI.Login/.nvmrc
@@ -1 +1 @@
-22
+24
diff --git a/src/Umbraco.Web.UI.Login/package-lock.json b/src/Umbraco.Web.UI.Login/package-lock.json
index 0e6ccb6e45ce..05b245068f4b 100644
--- a/src/Umbraco.Web.UI.Login/package-lock.json
+++ b/src/Umbraco.Web.UI.Login/package-lock.json
@@ -13,7 +13,7 @@
         "vite": "^7.3.1"
       },
       "engines": {
-        "node": ">=22",
+        "node": ">=24",
         "npm": ">=10.9"
       }
     },
diff --git a/src/Umbraco.Web.UI.Login/package.json b/src/Umbraco.Web.UI.Login/package.json
index 16e91e6e4d9b..737d6c4c71cb 100644
--- a/src/Umbraco.Web.UI.Login/package.json
+++ b/src/Umbraco.Web.UI.Login/package.json
@@ -10,7 +10,7 @@
     "generate:server-api": "openapi-ts"
   },
   "engines": {
-    "node": ">=22",
+    "node": ">=24",
     "npm": ">=10.9"
   },
   "devDependencies": {
diff --git a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
index c4566477c019..6c0cf31ebcb0 100644
--- a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
+++ b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj
@@ -26,7 +26,7 @@
 
   <ItemGroup>
     <!-- Add design/build time support for EF Core migrations -->
-    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" PrivateAssets="all" Version="10.0.3" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" PrivateAssets="all" Version="10.0.4" />
     <!--
     Added the following direct dependency due to Microsoft.EntityFrameworkCore.Design having a dependency on an insecure version.
     Review for removal when Microsoft.EntityFrameworkCore.Design is updated to a newer version.
diff --git a/tests/Directory.Packages.props b/tests/Directory.Packages.props
index 86e23c1b89ab..634b0ec9c71b 100644
--- a/tests/Directory.Packages.props
+++ b/tests/Directory.Packages.props
@@ -5,12 +5,12 @@
   <ItemGroup>
     <!-- Microsoft packages -->
     <PackageVersion Include="BenchmarkDotNet" Version="0.15.8" />
-    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.3" />
-    <PackageVersion Include="Microsoft.Extensions.Logging.Debug" Version="10.0.3" />
+    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.4" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Debug" Version="10.0.4" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
     <PackageVersion Include="System.Data.DataSetExtensions" Version="4.5.0" />
-    <PackageVersion Include="System.Data.Odbc" Version="10.0.3" />
-    <PackageVersion Include="System.Data.OleDb" Version="10.0.3" />
+    <PackageVersion Include="System.Data.Odbc" Version="10.0.4" />
+    <PackageVersion Include="System.Data.OleDb" Version="10.0.4" />
     <PackageVersion Include="System.Reflection.Emit" Version="4.7.0" />
   </ItemGroup>
   <ItemGroup>
diff --git a/tests/Umbraco.Tests.AcceptanceTest/lib/builders/dataTypes/blockGridBuilder/blockGridAreaBuilder.ts b/tests/Umbraco.Tests.AcceptanceTest/lib/builders/dataTypes/blockGridBuilder/blockGridAreaBuilder.ts
index 71ad3b086e43..4bf3900778eb 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/lib/builders/dataTypes/blockGridBuilder/blockGridAreaBuilder.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/lib/builders/dataTypes/blockGridBuilder/blockGridAreaBuilder.ts
@@ -94,7 +94,7 @@ export class BlockGridAreaBuilder {
     }
 
     if (this.blockGridSpecifiedAllowanceBuilder && this.blockGridSpecifiedAllowanceBuilder.length > 0) {
-      values.specifiedAllowances = this.blockGridSpecifiedAllowanceBuilder.map((builder) => {
+      values.specifiedAllowance = this.blockGridSpecifiedAllowanceBuilder.map((builder) => {
         return builder.getValues();
       });
     }
diff --git a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ConstantHelper.ts b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ConstantHelper.ts
index a877e4b7d2cb..6166e668274d 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ConstantHelper.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ConstantHelper.ts
@@ -43,7 +43,8 @@
     emptyValue: 'Value cannot be empty',
     nullValue: 'Value cannot be null',
     invalidEmail: 'Invalid email',
-    emptyManualLinkPicker: 'Please enter an URL or Anchor.'
+    emptyManualLinkPicker: 'Please enter an URL or Anchor.',
+    needMoreItems: 'This field needs more items',
   }
 
   public static readonly inputTypes = {
diff --git a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ContentUiHelper.ts b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ContentUiHelper.ts
index e977ed5f81d3..fde76faef2a3 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ContentUiHelper.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ContentUiHelper.ts
@@ -1210,14 +1210,8 @@ export class ContentUiHelper extends UiBaseLocators {
     await this.sliderInput.fill(value);
   }
 
-  async isDocumentTypeNameVisible(
-    contentName: string,
-    isVisible: boolean = true,
-  ) {
-    return await this.isVisible(
-      this.sidebarModal.getByText(contentName),
-      isVisible,
-    );
+  async isDocumentTypeNameVisible(contentName: string, isVisible: boolean = true) {
+    return await this.isVisible(this.sidebarModal.getByText(contentName), isVisible);
   }
 
   // Collection tab
diff --git a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DataTypeApiHelper.ts b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DataTypeApiHelper.ts
index 813da6d4becc..f2f795b9c550 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DataTypeApiHelper.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DataTypeApiHelper.ts
@@ -604,6 +604,96 @@ export class DataTypeApiHelper {
     return await this.save(blockGrid);
   }
 
+  async createBlockGridWithAnAreaWithSpecifiedAllowanceInABlock(blockGridName: string, contentElementTypeId: string, specifiedAllowanceElementTypeId: string, areaAlias: string = 'area', createLabel: string = 'CreateLabel', columnSpan: number = 6, rowSpan: number = 1) {
+    await this.ensureNameNotExists(blockGridName);
+
+    const blockGrid = new BlockGridDataTypeBuilder()
+      .withName(blockGridName)
+      .addBlock()
+        .withContentElementTypeKey(contentElementTypeId)
+        .withAllowAtRoot(true)
+        .addArea()
+          .withAlias(areaAlias)
+          .withCreateLabel(createLabel)
+          .withColumnSpan(columnSpan)
+          .withRowSpan(rowSpan)
+          .addSpecifiedAllowance()
+            .withElementTypeKey(specifiedAllowanceElementTypeId)
+            .done()
+          .done()
+        .done()
+      .addBlock()
+        .withContentElementTypeKey(specifiedAllowanceElementTypeId)
+        .withAllowInAreas(true)
+        .done()
+      .build();
+
+    return await this.save(blockGrid);
+  }
+
+  async createBlockGridWithAnAreaWithSpecifiedAllowanceWithMinMaxInABlock(blockGridName: string, contentElementTypeId: string, specifiedAllowanceElementTypeId: string, minAllowed: number, maxAllowed: number, areaAlias: string = 'area', createLabel: string = 'CreateLabel', columnSpan: number = 6, rowSpan: number = 1) {
+    await this.ensureNameNotExists(blockGridName);
+
+    const blockGrid = new BlockGridDataTypeBuilder()
+      .withName(blockGridName)
+      .addBlock()
+        .withContentElementTypeKey(contentElementTypeId)
+        .withAllowAtRoot(true)
+        .addArea()
+          .withAlias(areaAlias)
+          .withCreateLabel(createLabel)
+          .withColumnSpan(columnSpan)
+          .withRowSpan(rowSpan)
+          .addSpecifiedAllowance()
+            .withElementTypeKey(specifiedAllowanceElementTypeId)
+            .withMinAllowed(minAllowed)
+            .withMaxAllowed(maxAllowed)
+            .done()
+          .done()
+        .done()
+      .addBlock()
+        .withContentElementTypeKey(specifiedAllowanceElementTypeId)
+        .withAllowInAreas(true)
+        .done()
+      .build();
+
+    return await this.save(blockGrid);
+  }
+
+  async createBlockGridWithAnAreaWithTwoSpecifiedAllowancesInABlock(blockGridName: string, contentElementTypeId: string, firstSpecifiedAllowanceElementTypeId: string, secondSpecifiedAllowanceElementTypeId: string, areaAlias: string = 'area', createLabel: string = 'CreateLabel', columnSpan: number = 6, rowSpan: number = 1) {
+    await this.ensureNameNotExists(blockGridName);
+
+    const blockGrid = new BlockGridDataTypeBuilder()
+      .withName(blockGridName)
+      .addBlock()
+        .withContentElementTypeKey(contentElementTypeId)
+        .withAllowAtRoot(true)
+        .addArea()
+          .withAlias(areaAlias)
+          .withCreateLabel(createLabel)
+          .withColumnSpan(columnSpan)
+          .withRowSpan(rowSpan)
+          .addSpecifiedAllowance()
+            .withElementTypeKey(firstSpecifiedAllowanceElementTypeId)
+            .done()
+          .addSpecifiedAllowance()
+            .withElementTypeKey(secondSpecifiedAllowanceElementTypeId)
+            .done()
+          .done()
+        .done()
+      .addBlock()
+        .withContentElementTypeKey(firstSpecifiedAllowanceElementTypeId)
+        .withAllowInAreas(true)
+        .done()
+      .addBlock()
+        .withContentElementTypeKey(secondSpecifiedAllowanceElementTypeId)
+        .withAllowInAreas(true)
+        .done()
+      .build();
+
+    return await this.save(blockGrid);
+  }
+
   async createBlockGridWithAnAreaInABlockWithAllowInAreas(blockGridName: string, contentElementTypeId: string, areaAlias: string = 'area', allowInAreas = false, createButtonLabel :string = 'CreateLabel', columnSpan: number = 6, rowSpan: number = 1, minAllowed: number = 0, maxAllowed: number = 2) {
     await this.ensureNameNotExists(blockGridName);
 
@@ -941,11 +1031,35 @@ export class DataTypeApiHelper {
   }
 
   async doesBlockEditorBlockContainAreaWithSpecifiedAllowance(blockGridName: string, elementTypeKey: string, areaAlias: string = 'area') {
-    const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
-    const area = block.areas.find(area => area.alias === areaAlias);
+    const area = await this.getBlockAreaByAlias(blockGridName, elementTypeKey, areaAlias);
     return area && area.specifiedAllowance && area.specifiedAllowance.length > 0;
   }
 
+  async doesBlockGridBlockContainAreaWithSpecifiedAllowanceForElementType(blockGridName: string, elementTypeKey: string, specifiedAllowanceElementTypeKey: string, areaAlias: string = 'area') {
+    const area = await this.getBlockAreaByAlias(blockGridName, elementTypeKey, areaAlias);
+    return area && area.specifiedAllowance && area.specifiedAllowance.some(sa => sa.elementTypeKey === specifiedAllowanceElementTypeKey);
+  }
+
+  async doesBlockGridBlockContainAreaWithSpecifiedAllowanceCount(blockGridName: string, elementTypeKey: string, count: number, areaAlias: string = 'area') {
+    const area = await this.getBlockAreaByAlias(blockGridName, elementTypeKey, areaAlias);
+    return area && area.specifiedAllowance && area.specifiedAllowance.length === count;
+  }
+
+  async doesBlockGridBlockContainAreaWithSpecifiedAllowanceMinMax(blockGridName: string, elementTypeKey: string, specifiedAllowanceElementTypeKey: string, minAllowed: number, maxAllowed: number, areaAlias: string = 'area') {
+    const area = await this.getBlockAreaByAlias(blockGridName, elementTypeKey, areaAlias);
+    return area && area.specifiedAllowance &&
+      area.specifiedAllowance.some(sa =>
+        sa.elementTypeKey === specifiedAllowanceElementTypeKey &&
+        sa.minAllowed === minAllowed &&
+        sa.maxAllowed === maxAllowed
+      );
+  }
+
+  private async getBlockAreaByAlias(blockGridName: string, elementTypeKey: string, areaAlias: string) {
+    const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+    return block.areas.find(area => area.alias === areaAlias);
+  }
+
   async doesBlockEditorBlockContainStylesheet(blockGridName: string, elementTypeKey: string, stylesheetPath: string) {
     const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
     const encodedSecondStylesheetPath = await this.api.stylesheet.encodeStylesheetPath(stylesheetPath);
@@ -1854,6 +1968,17 @@ export class DataTypeApiHelper {
     return await this.save(dataType);
   }
 
+  async createMultiUrlPickerDataTypeWithMinNumberOfItems(name: string, minNumber: number) {
+    await this.ensureNameNotExists(name);
+
+    const dataType = new MultiUrlPickerDataTypeBuilder()
+      .withName(name)
+      .withMinNumber(minNumber)
+      .build();
+
+    return await this.save(dataType);
+  }
+
   async createDefaultNumericDataType(name: string) {
     await this.ensureNameNotExists(name);
 
diff --git a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DataTypeUiHelper.ts b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DataTypeUiHelper.ts
index c3f41ab45d9f..a7ea330027ac 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DataTypeUiHelper.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DataTypeUiHelper.ts
@@ -61,6 +61,7 @@ export class DataTypeUiHelper extends UiBaseLocators {
   private readonly labelOffTxt: Locator;
   private readonly labelTxt: Locator;
   private readonly chooseAcceptedTypesBtn: Locator;
+  private readonly chooseAllowedMediaTypesBtn: Locator;
   private readonly chooseWithPlusBtn: Locator;
   private readonly storageTypeDropDownBox: Locator;
   private readonly allowDecimalsToggle: Locator;
@@ -146,6 +147,8 @@ export class DataTypeUiHelper extends UiBaseLocators {
   private readonly dynamicRootOriginPickerModal: Locator;
   private readonly dynamicRootQueryStepPickerModal: Locator;
   private readonly closeDynamicRootOriginPickerModalBtn: Locator;
+  private readonly specifiedAllowance: Locator;
+  private readonly specifiedAllowanceItems: Locator;
 
   constructor(page: Page) {
     super(page);
@@ -224,7 +227,8 @@ export class DataTypeUiHelper extends UiBaseLocators {
     this.amountLowValueTxt = page.getByTestId('property:validationLimit').getByLabel('Low value');
     this.amountHighValueTxt = page.getByTestId('property:validationLimit').getByLabel('High value');
     this.chooseAcceptedTypesBtn = page.getByTestId('property:filter').getByLabel('Choose');
-    this.chooseWithPlusBtn = page.locator('#btn-add').filter({hasText: 'Choose'});
+    this.chooseAllowedMediaTypesBtn = page.getByTestId('property:allowedMediaTypes').locator('#btn-add');
+    this.chooseWithPlusBtn = page.getByTestId('property:mediaParentId').locator('#btn-add');
     this.chooseStartNodeBtn = page.getByTestId('property:startNodeId').locator('#btn-add');
 
     // Rich Editor
@@ -297,13 +301,15 @@ export class DataTypeUiHelper extends UiBaseLocators {
     this.createLabelTxt = this.page.locator('[alias="createLabel"]').locator('#input');
     this.minAllowedTxt = this.page.locator('#container').getByLabel('Low value');
     this.maxAllowedTxt = this.page.locator('#container').getByLabel('High value');
-    this.addSpecifiedAllowanceBtn = this.page.locator('[alias="specifiedAllowance"]').getByLabel('Add');
     this.advancedTabBtn = this.page.getByRole('tab', {name: 'Advanced'});
     this.allowBlockAtRootToggle = this.page.getByTestId('property:allowAtRoot').locator('#toggle');
     this.allowInAreasToggle = this.page.getByTestId('property:allowInAreas').locator('#toggle');
     this.expandChildItemsForMediaBtn = this.page.getByLabel('Expand child items for media', {exact: true});
     this.chooseCustomStylesheetBtn = this.page.locator('[label="Custom stylesheet"]').getByLabel('Choose');
     this.blockThumbnailRemoveBtn = this.page.getByTestId('property:thumbnail').getByLabel('Remove', {exact: true});
+    this.specifiedAllowance = this.page.getByTestId('property:specifiedAllowance');
+    this.addSpecifiedAllowanceBtn = this.specifiedAllowance.getByLabel('Add');
+    this.specifiedAllowanceItems = this.specifiedAllowance.locator('.permission-setting');
 
     // Tiptap
     this.tiptapToolbarConfiguration = this.page.locator('umb-property-editor-ui-tiptap-toolbar-configuration');
@@ -684,6 +690,17 @@ export class DataTypeUiHelper extends UiBaseLocators {
     await this.click(this.confirmToRemoveBtn);
   }
 
+  async addAllowedMediaType(mediaTypeName: string) {
+    await this.click(this.chooseAllowedMediaTypesBtn);
+    await this.clickTextButtonWithName(mediaTypeName);
+    await this.click(this.chooseModalBtn);
+  }
+
+  async removeAllowedMediaType(mediaTypeName: string) {
+    await this.click(this.page.getByTestId('property:allowedMediaTypes').locator(`uui-ref-node-document-type[name="${mediaTypeName}"]`).getByLabel('Remove'));
+    await this.click(this.confirmToRemoveBtn);
+  }
+
   async removeMediaStartNode(mediaName: string) {
     await this.click(this.page.locator(`uui-card-media[name="${mediaName}"]`).locator('[label="Remove"]'));
     await this.click(this.confirmToRemoveBtn);
@@ -835,7 +852,7 @@ export class DataTypeUiHelper extends UiBaseLocators {
   }
 
   async goToBlockWithName(name: string) {
-    await this.click(this.page.getByRole('link', {name: name}));
+    await this.click(this.page.getByRole('link', {name: name, exact: true}));
   }
 
   async enterBlockLabelText(label: string) {
@@ -1058,6 +1075,41 @@ export class DataTypeUiHelper extends UiBaseLocators {
     await this.click(this.addSpecifiedAllowanceBtn);
   }
 
+  async clickSpecifiedAllowanceComboboxByIndex(index: number = 0) {
+    const combobox = this.specifiedAllowanceItems.nth(index).locator('uui-combobox');
+    await this.click(combobox);
+  }
+
+  async selectSpecifiedAllowanceOptionByName(elementTypeName: string) {
+    const option = this.specifiedAllowanceItems.locator('uui-combobox-list-option').filter({hasText: elementTypeName});
+    await this.click(option);
+  }
+
+  async clickRemoveSpecifiedAllowanceByIndex(index: number = 0) {
+    const removeBtn = this.specifiedAllowanceItems.nth(index).locator('uui-button[label="Remove"]');
+    await this.click(removeBtn);
+  }
+
+  async enterSpecifiedAllowanceMinByIndex(value: number | undefined, index: number = 0) {
+    const minInput = this.specifiedAllowanceItems.nth(index).locator('uui-input[type="number"]').first().locator('input');
+    if (value === undefined) {
+      await this.focus(minInput); // Focus is needed
+      await this.clearText(minInput);
+      return;
+    } 
+    await this.enterText(minInput, value.toString());
+  }
+
+  async enterSpecifiedAllowanceMaxByIndex(value: number | undefined, index: number = 0) {
+    const maxInput = this.specifiedAllowanceItems.nth(index).locator('uui-input[type="number"]').nth(1).locator('input');
+    if (value === undefined) {
+      await this.focus(maxInput); // Focus is needed
+      await this.clearText(maxInput);
+      return;
+    }
+    await this.enterText(maxInput, value.toString());
+  }
+
   async goToBlockAdvancedTab() {
     await this.click(this.advancedTabBtn);
   }
diff --git a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DocumentApiHelper.ts b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DocumentApiHelper.ts
index 123061443c6b..3104d2fd113b 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DocumentApiHelper.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/DocumentApiHelper.ts
@@ -326,7 +326,7 @@ export class DocumentApiHelper {
     return await this.create(document);
   }
 
-  async createDocumentWithExternalLinkURLPicker(documentName: string, documentTypeId: string, link: string, linkTitle: string) {
+  async createDocumentWithExternalLinkURLPicker(documentName: string, documentTypeId: string, dataTypeName: string, link: string, linkTitle: string) {
     await this.ensureNameNotExists(documentName);
 
     const document = new DocumentBuilder()
@@ -335,7 +335,7 @@ export class DocumentApiHelper {
         .withName(documentName)
         .done()
       .addValue()
-        .withAlias('multiUrlPicker')
+        .withAlias(AliasHelper.toAlias(dataTypeName))
         .addURLPickerValue()
           .withIcon('icon-link')
           .withName(linkTitle)
diff --git a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ElementApiHelper.ts b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ElementApiHelper.ts
index 57bfc7e7ce34..8881e1575e31 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ElementApiHelper.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/ElementApiHelper.ts
@@ -162,11 +162,12 @@ export class ElementApiHelper {
     return response.status();
   }
 
-  async moveToRecycleBin(id: string) {
+  async moveToRecycleBin(id: string, isFolder: boolean = false) {
     if (id == null) {
       return;
     }
-    const response = await this.api.put(`${this.api.baseUrl}${ConstantHelper.apiEndpoints.element}/${id}/move-to-recycle-bin`);
+    const endpoint = isFolder ? ConstantHelper.apiEndpoints.elementFolder : ConstantHelper.apiEndpoints.element;
+    const response = await this.api.put(`${this.api.baseUrl}${endpoint}/${id}/move-to-recycle-bin`);
     return response.status();
   }
 
diff --git a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/LibraryUiHelper.ts b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/LibraryUiHelper.ts
index b3418d074d0b..6ecb8483f964 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/LibraryUiHelper.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/LibraryUiHelper.ts
@@ -231,7 +231,7 @@ export class LibraryUiHelper extends UiBaseLocators {
     this.selectAVariantBtn = page.getByRole('button', {name: 'Open version selector'});
     this.variantAddModeBtn = page.locator('.switch-button.add-mode').locator('.variant-name');
     this.saveAndCloseBtn = page.getByLabel('Save and close');
-    this.elementTreeItem = page.locator('umb-default-tree-item');
+    this.elementTreeItem = page.locator('umb-element-tree-item');
     this.elementLanguageSelect = page.locator('umb-app-language-select');
     this.elementLanguageSelectPopover = page.locator('umb-popover-layout');
     this.elementReadOnly = this.elementWorkspace.locator('#name-input').getByText('Read-only');
@@ -872,10 +872,6 @@ export class LibraryUiHelper extends UiBaseLocators {
     return await this.isVisible(this.sidebarModal.getByText(elementName), isVisible); 
   }
 
-  async doesModalHaveText(text: string) {
-    await this.containsText(this.openedModal, text);
-  }
-
   // Collection tab
   async isTabNameVisible(tabName: string) {
     return await this.isVisible(this.tabItems.filter({hasText: tabName}));
diff --git a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/UiBaseLocators.ts b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/UiBaseLocators.ts
index 4abf8cb97452..846ff797895b 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/UiBaseLocators.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/lib/helpers/UiBaseLocators.ts
@@ -2065,14 +2065,13 @@ export class UiBaseLocators extends BasePage {
     await this.click(this.elementStartNode.filter({hasText: elementStartNodeName}).getByLabel('Remove'));
   }
 
-  async isSelectCheckboxVisibleForMediaName(
-    mediaName: string,
-    isVisible: boolean = true,
-  ) {
-    const selectCheckboxLocator = this.mediaCardItems
-      .filter({ hasText: mediaName })
-      .locator("#select-checkbox");
+  async isRestoreFromRecycleBinMessageVisible(restoreItem: string, targetFolderName: string) {
+    const message = 'Restore ' + restoreItem + ' to ' + targetFolderName;
+    return await this.doesModalHaveText(message);
+  }
 
+  async isSelectCheckboxVisibleForMediaName(mediaName: string, isVisible: boolean = true) {
+    const selectCheckboxLocator = this.mediaCardItems.filter({hasText: mediaName}).locator('#select-checkbox');
     await this.isVisible(selectCheckboxLocator, isVisible);
   }
 }
diff --git a/tests/Umbraco.Tests.AcceptanceTest/package.json b/tests/Umbraco.Tests.AcceptanceTest/package.json
index 53d0f06f9dc1..c2046268475b 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/package.json
+++ b/tests/Umbraco.Tests.AcceptanceTest/package.json
@@ -1,6 +1,6 @@
 {
-  "name": "@umbraco/acceptance-test-helpers",
-  "version": "18.0.0-rc",
+  "name": "@umbraco-cms/acceptance-test-helpers",
+  "version": "18.0.0-beta",
   "description": "Test helpers and builders for making Playwright tests for Umbraco solutions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/ContentSettingConfig/AdditionalSetup/appsettings.json b/tests/Umbraco.Tests.AcceptanceTest/tests/ContentSettingConfig/AdditionalSetup/appsettings.json
index 2590995e5b7b..ff61e50ee513 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/ContentSettingConfig/AdditionalSetup/appsettings.json
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/ContentSettingConfig/AdditionalSetup/appsettings.json
@@ -49,9 +49,6 @@
           "Enabled": false
         }
       },
-      "KeepAlive": {
-        "DisableKeepAliveTask": true
-      },
       "WebRouting": {
         "UmbracoApplicationUrl": "https://localhost:44331/"
       }
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/BlockGrid/BlockGridArea.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/BlockGrid/BlockGridArea.spec.ts
index 895427647eba..be3f5d3a47b5 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/BlockGrid/BlockGridArea.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/BlockGrid/BlockGridArea.spec.ts
@@ -12,6 +12,7 @@ const contentName = 'TestContent';
 const firstElementTypeName = 'FirstBlockGridElement';
 let firstElementTypeId = null;
 const secondElementTypeName = 'SecondBlockGridElement';
+const thirdElementTypeName = 'ThirdBlockGridElement';
 
 // Block Grid Data Type
 const blockGridDataTypeName = 'BlockGridTester';
@@ -20,29 +21,26 @@ const firstAreaName = 'FirstArea';
 const areaCreateLabel = 'CreateLabel';
 const toAllowInAreas = true;
 
-test.beforeEach(async ({umbracoApi}) => {
-  await umbracoApi.documentType.ensureNameNotExists(documentTypeName);
-  await umbracoApi.documentType.ensureNameNotExists(firstElementTypeName);
-  await umbracoApi.documentType.ensureNameNotExists(secondElementTypeName);
+test.beforeEach(async ({umbracoApi, umbracoUi}) => {
   await umbracoApi.document.ensureNameNotExists(contentName);
-  await umbracoApi.dataType.ensureNameNotExists(blockGridDataTypeName);
+  firstElementTypeId = await umbracoApi.documentType.createEmptyElementType(firstElementTypeName);
+  await umbracoUi.goToBackOffice();
 });
 
 test.afterEach(async ({umbracoApi}) => {
   await umbracoApi.documentType.ensureNameNotExists(documentTypeName);
   await umbracoApi.documentType.ensureNameNotExists(firstElementTypeName);
   await umbracoApi.documentType.ensureNameNotExists(secondElementTypeName);
+  await umbracoApi.documentType.ensureNameNotExists(thirdElementTypeName);
   await umbracoApi.document.ensureNameNotExists(contentName);
   await umbracoApi.dataType.ensureNameNotExists(blockGridDataTypeName);
 });
 
 test('can create content with a block grid with an empty block in a area', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
   // Arrange
-  firstElementTypeId = await umbracoApi.documentType.createEmptyElementType(firstElementTypeName);
   blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaInABlockWithAllowInAreas(blockGridDataTypeName, firstElementTypeId, firstAreaName, toAllowInAreas, areaCreateLabel);
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
   await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
   await umbracoUi.content.goToContentWithName(contentName);
 
@@ -61,11 +59,9 @@ test('can create content with a block grid with an empty block in a area', {tag:
 
 test('can create content with a block grid with two empty blocks in a area', async ({umbracoApi, umbracoUi}) => {
   // Arrange
-  firstElementTypeId = await umbracoApi.documentType.createEmptyElementType(firstElementTypeName);
   blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaInABlockWithAllowInAreas(blockGridDataTypeName, firstElementTypeId, firstAreaName, toAllowInAreas, areaCreateLabel);
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
   await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
   await umbracoUi.content.goToContentWithName(contentName);
 
@@ -92,12 +88,10 @@ test('can create content with a block grid with two empty blocks in a area', asy
 
 test('can create content with block grid area with a create label', async ({umbracoApi, umbracoUi}) => {
   // Arrange
-  firstElementTypeId = await umbracoApi.documentType.createEmptyElementType(firstElementTypeName);
   const createLabel = 'ThisIsACreateLabel';
   blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaInABlockWithACreateLabel(blockGridDataTypeName, firstElementTypeId, createLabel, firstAreaName);
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
   await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
   await umbracoUi.content.goToContentWithName(contentName);
 
@@ -112,12 +106,10 @@ test('can create content with block grid area with a create label', async ({umbr
 
 test('can create content with block grid area with column span', async ({umbracoApi, umbracoUi}) => {
   // Arrange
-  firstElementTypeId = await umbracoApi.documentType.createEmptyElementType(firstElementTypeName);
   const columnSpan = 2;
   blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaInABlockWithColumnSpanAndRowSpan(blockGridDataTypeName, firstElementTypeId, columnSpan, 1, firstAreaName, areaCreateLabel);
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
   await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
   await umbracoUi.content.goToContentWithName(contentName);
 
@@ -132,12 +124,10 @@ test('can create content with block grid area with column span', async ({umbraco
 
 test('can create content with block grid area with row span', async ({umbracoApi, umbracoUi}) => {
   // Arrange
-  firstElementTypeId = await umbracoApi.documentType.createEmptyElementType(firstElementTypeName);
   const rowSpan = 4;
   blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaInABlockWithColumnSpanAndRowSpan(blockGridDataTypeName, firstElementTypeId, 12, rowSpan, firstAreaName, areaCreateLabel);
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
   await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
   await umbracoUi.content.goToContentWithName(contentName);
 
@@ -153,13 +143,11 @@ test('can create content with block grid area with row span', async ({umbracoApi
 // Skip this test due to this issue: https://github.com/umbraco/Umbraco-CMS/issues/22121
 test.skip('can create content with block grid area with min allowed', async ({umbracoApi, umbracoUi}) => {
   // Arrange
-  firstElementTypeId = await umbracoApi.documentType.createEmptyElementType(firstElementTypeName);
   const secondElementTypeId = await umbracoApi.documentType.createEmptyElementType(secondElementTypeName);
   const minAllowed = 2;
   blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaInABlockWithMinAndMaxAllowed(blockGridDataTypeName, firstElementTypeId, secondElementTypeId, minAllowed, 10, firstAreaName, areaCreateLabel);
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
   await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
   await umbracoUi.content.goToContentWithName(contentName);
 
@@ -188,13 +176,11 @@ test.skip('can create content with block grid area with min allowed', async ({um
 // Skip this test due to this issue: https://github.com/umbraco/Umbraco-CMS/issues/22121
 test.skip('can create content with block grid area with max allowed', async ({umbracoApi, umbracoUi}) => {
   // Arrange
-  firstElementTypeId = await umbracoApi.documentType.createEmptyElementType(firstElementTypeName);
   const secondElementTypeId = await umbracoApi.documentType.createEmptyElementType(secondElementTypeName);
   const maxAllowed = 0;
   blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaInABlockWithMinAndMaxAllowed(blockGridDataTypeName, firstElementTypeId, secondElementTypeId, 0, maxAllowed, firstAreaName, areaCreateLabel);
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
   await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
   await umbracoUi.content.goToContentWithName(contentName);
 
@@ -219,3 +205,105 @@ test.skip('can create content with block grid area with max allowed', async ({um
   // Clean
   await umbracoApi.documentType.ensureNameNotExists(secondElementTypeName);
 });
+
+test('can create content with a block grid area with specified allowance', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const secondElementTypeId = await umbracoApi.documentType.createEmptyElementType(secondElementTypeName);
+  blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaWithSpecifiedAllowanceInABlock(blockGridDataTypeName, firstElementTypeId, secondElementTypeId, firstAreaName, areaCreateLabel);
+  documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
+  await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+  await umbracoUi.content.goToContentWithName(contentName);
+
+  // Act
+  await umbracoUi.content.clickAddBlockGridElementWithName(firstElementTypeName);
+  await umbracoUi.content.clickSelectBlockElementWithName(firstElementTypeName);
+  await umbracoUi.content.clickLinkWithName(areaCreateLabel);
+  await umbracoUi.content.clickSelectBlockElementInAreaWithName(secondElementTypeName);
+  await umbracoUi.content.clickSaveAndPublishButtonAndWaitForContentToBePublished();
+
+  // Assert
+  await umbracoUi.content.doesBlockContainBlockInAreaWithName(firstElementTypeName, firstAreaName, secondElementTypeName);
+  await umbracoUi.content.doesBlockContainBlockCountInArea(firstElementTypeName, firstAreaName, 1);
+});
+
+test('can create content with a block grid area with specified allowance with min allowed', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const secondElementTypeId = await umbracoApi.documentType.createEmptyElementType(secondElementTypeName);
+  const minAllowed = 2;
+  const warningMessage = secondElementTypeName + ' must be present at least ' + minAllowed + ' time(s).';
+  blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaWithSpecifiedAllowanceWithMinMaxInABlock(blockGridDataTypeName, firstElementTypeId, secondElementTypeId, minAllowed, 10, firstAreaName, areaCreateLabel);
+  documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
+  await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+  await umbracoUi.content.goToContentWithName(contentName);
+
+  // Act
+  await umbracoUi.content.clickAddBlockGridElementWithName(firstElementTypeName);
+  await umbracoUi.content.clickSelectBlockElementWithName(firstElementTypeName);
+  await umbracoUi.content.clickLinkWithName(areaCreateLabel);
+  await umbracoUi.content.clickSelectBlockElementInAreaWithName(secondElementTypeName);
+  await umbracoUi.content.isTextWithExactNameVisible(warningMessage);
+  await umbracoUi.content.clickSaveAndPublishButton();
+  await umbracoUi.content.doesErrorNotificationHaveText(NotificationConstantHelper.error.documentCouldNotBePublished);
+  await umbracoUi.content.clickInlineAddToAreaButton(firstElementTypeName, firstAreaName, 0, 1);
+  await umbracoUi.content.clickSelectBlockElementInAreaWithName(secondElementTypeName);
+  await umbracoUi.content.clickSaveAndPublishButtonAndWaitForContentToBePublished();
+
+  // Assert
+  await umbracoUi.content.doesBlockContainBlockCountInArea(firstElementTypeName, firstAreaName, 2);
+});
+
+test('can create content with a block grid area with specified allowance with max allowed', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const secondElementTypeId = await umbracoApi.documentType.createEmptyElementType(secondElementTypeName);
+  const maxAllowed = 1;
+  const warningMessage = secondElementTypeName + ' must maximum be present ' + maxAllowed + ' time(s).';
+  blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaWithSpecifiedAllowanceWithMinMaxInABlock(blockGridDataTypeName, firstElementTypeId, secondElementTypeId, 0, maxAllowed, firstAreaName, areaCreateLabel);
+  documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
+  await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+  await umbracoUi.content.goToContentWithName(contentName);
+
+  // Act
+  await umbracoUi.content.clickAddBlockGridElementWithName(firstElementTypeName);
+  await umbracoUi.content.clickSelectBlockElementWithName(firstElementTypeName);
+  await umbracoUi.content.clickLinkWithName(areaCreateLabel);
+  await umbracoUi.content.clickSelectBlockElementInAreaWithName(secondElementTypeName);
+  await umbracoUi.content.clickInlineAddToAreaButton(firstElementTypeName, firstAreaName, 0, 1);
+  await umbracoUi.content.clickSelectBlockElementInAreaWithName(secondElementTypeName);
+  await umbracoUi.content.isTextWithExactNameVisible(warningMessage);
+  await umbracoUi.content.clickSaveAndPublishButton();
+  await umbracoUi.content.doesErrorNotificationHaveText(NotificationConstantHelper.error.documentCouldNotBePublished);
+  await umbracoUi.content.removeBlockFromArea(firstElementTypeName, firstAreaName, secondElementTypeName);
+  await umbracoUi.content.clickConfirmToDeleteButton();
+  await umbracoUi.content.clickSaveAndPublishButtonAndWaitForContentToBePublished();
+
+  // Assert
+  await umbracoUi.content.doesBlockContainBlockCountInArea(firstElementTypeName, firstAreaName, 1);
+});
+
+test('can create content with a block grid area with multiple specified allowances', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const secondElementTypeId = await umbracoApi.documentType.createEmptyElementType(secondElementTypeName);
+  const thirdElementTypeId = await umbracoApi.documentType.createEmptyElementType(thirdElementTypeName);
+  blockGridDataTypeId = await umbracoApi.dataType.createBlockGridWithAnAreaWithTwoSpecifiedAllowancesInABlock(blockGridDataTypeName, firstElementTypeId, secondElementTypeId, thirdElementTypeId, firstAreaName, areaCreateLabel);
+  documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockGridDataTypeName, blockGridDataTypeId);
+  await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+  await umbracoUi.content.goToContentWithName(contentName);
+
+  // Act
+  await umbracoUi.content.clickAddBlockGridElementWithName(firstElementTypeName);
+  await umbracoUi.content.clickSelectBlockElementWithName(firstElementTypeName);
+  await umbracoUi.content.clickLinkWithName(areaCreateLabel);
+  await umbracoUi.content.clickSelectBlockElementInAreaWithName(secondElementTypeName);
+  await umbracoUi.content.clickInlineAddToAreaButton(firstElementTypeName, firstAreaName, 0, 1);
+  await umbracoUi.content.clickSelectBlockElementInAreaWithName(thirdElementTypeName);
+  await umbracoUi.content.clickSaveAndPublishButtonAndWaitForContentToBePublished();
+
+  // Assert
+  await umbracoUi.content.doesBlockContainBlockInAreaWithName(firstElementTypeName, firstAreaName, secondElementTypeName);
+  await umbracoUi.content.doesBlockContainBlockInAreaWithName(firstElementTypeName, firstAreaName, thirdElementTypeName);
+  await umbracoUi.content.doesBlockContainBlockCountInArea(firstElementTypeName, firstAreaName, 2);
+});
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/BlockList/BlockListWithPropertyEditor.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/BlockList/BlockListWithPropertyEditor.spec.ts
index b554fb4e4651..90b6924a7a6d 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/BlockList/BlockListWithPropertyEditor.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/BlockList/BlockListWithPropertyEditor.spec.ts
@@ -4,31 +4,32 @@ import {expect} from "@playwright/test";
 // Content Name
 const contentName = 'ContentName';
 let contentId = null;
-
 // Document Type
 const documentTypeName = 'DocumentTypeName';
 let documentTypeId = null;
 const documentTypeGroupName = 'DocumentGroup';
-
 // Block List
 const blockListName = 'BlockListName';
 let blockListId = null;
-
 // Element Type
 const blockName = 'BlockName';
 let elementTypeId = null;
 const elementGroupName = 'ElementGroup';
-
 // Property Editor
 const propertyEditorName = 'ProperyEditorInBlockName';
 let propertyEditorId = null;
 const optionValues = ['testOption1', 'testOption2'];
 
+test.beforeEach(async ({umbracoUi}) => {
+  await umbracoUi.goToBackOffice();
+});
+
 test.afterEach(async ({umbracoApi}) => {
   await umbracoApi.document.ensureNameNotExists(contentName);
   await umbracoApi.documentType.ensureNameNotExists(documentTypeName);
   await umbracoApi.documentType.ensureNameNotExists(blockName);
   await umbracoApi.dataType.ensureNameNotExists(blockListName);
+  await umbracoApi.dataType.ensureNameNotExists(propertyEditorName);
 });
 
 test('cannot publish a block list with a mandatory radiobox without a value', async ({umbracoApi, umbracoUi}) => {
@@ -38,8 +39,6 @@ test('cannot publish a block list with a mandatory radiobox without a value', as
   blockListId = await umbracoApi.dataType.createBlockListDataTypeWithABlock(blockListName, elementTypeId);
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockListName, blockListId, documentTypeGroupName);
   contentId = await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
   await umbracoUi.content.goToContentWithName(contentName);
 
@@ -66,8 +65,6 @@ test('cannot publish a block list with a mandatory checkbox list without a value
   blockListId = await umbracoApi.dataType.createBlockListDataTypeWithABlock(blockListName, elementTypeId);
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockListName, blockListId, documentTypeGroupName);
   contentId = await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
   await umbracoUi.content.goToContentWithName(contentName);
 
@@ -94,8 +91,6 @@ test('cannot publish a block list with a mandatory dropdown without a value', as
   blockListId = await umbracoApi.dataType.createBlockListDataTypeWithABlock(blockListName, elementTypeId);
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockListName, blockListId, documentTypeGroupName);
   contentId = await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
   await umbracoUi.content.goToContentWithName(contentName);
 
@@ -132,7 +127,6 @@ test('cannot update a variant block list with invalid text', {tag: '@release'},
   documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockListName, blockListId, documentTypeGroupName, true, true);
   // Creates content
   contentId = await umbracoApi.document.createDefaultDocumentWithEnglishCulture(contentName, documentTypeId);
-  await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
 
   // Act
@@ -161,4 +155,35 @@ test('cannot update a variant block list with invalid text', {tag: '@release'},
   expect(blockListValue).toBeTruthy();
   await umbracoUi.content.clickEditBlockListEntryWithName(blockName);
   await umbracoUi.content.doesPropertyContainValue(textStringElementDataTypeName, correctPropertyValue);
+});
+
+test('cannot publish a block list with an empty mandatory multi url picker until a link is added', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  propertyEditorId = await umbracoApi.dataType.createDefaultMultiUrlPickerDataType(propertyEditorName);
+  elementTypeId = await umbracoApi.documentType.createDefaultElementType(blockName, elementGroupName, propertyEditorName, propertyEditorId, true);
+  blockListId = await umbracoApi.dataType.createBlockListDataTypeWithABlock(blockListName, elementTypeId);
+  documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, blockListName, blockListId, documentTypeGroupName);
+  contentId = await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+  await umbracoUi.content.goToContentWithName(contentName);
+
+  // Act
+  await umbracoUi.content.clickAddBlockElementButton();
+  await umbracoUi.content.clickBlockElementWithName(blockName);
+  // Do not add any links, try to create - validation error appears
+  await umbracoUi.content.clickCreateModalButton();
+  await umbracoUi.content.isValidationMessageVisible(ConstantHelper.validationMessages.emptyValue);
+  // Add a manual link - validation error disappears
+  await umbracoUi.content.clickAddMultiURLPickerButton();
+  await umbracoUi.content.clickManualLinkButton();
+  await umbracoUi.content.enterLink('https://docs.umbraco.com');
+  await umbracoUi.content.enterLinkTitle('Umbraco Documentation');
+  await umbracoUi.content.clickLinkPickerAddButton();
+  await umbracoUi.content.isValidationMessageVisible(ConstantHelper.validationMessages.emptyValue, false);
+  await umbracoUi.content.clickCreateModalButton();
+  await umbracoUi.content.clickSaveAndPublishButtonAndWaitForContentToBePublished();
+
+  // Assert
+  await umbracoUi.content.isErrorNotificationVisible(false);
+  expect(await umbracoApi.document.isDocumentPublished(contentId)).toBeTruthy();
 });
\ No newline at end of file
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/ContentWithMultiURLPicker.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/MultiURLPicker/ContentWithMultiURLPicker.spec.ts
similarity index 70%
rename from tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/ContentWithMultiURLPicker.spec.ts
rename to tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/MultiURLPicker/ContentWithMultiURLPicker.spec.ts
index aac479c85d59..c7892fd1bf8a 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/ContentWithMultiURLPicker.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/MultiURLPicker/ContentWithMultiURLPicker.spec.ts
@@ -6,10 +6,6 @@ const contentName = 'TestContent';
 const documentTypeName = 'TestDocumentTypeForContent';
 const link = 'https://docs.umbraco.com';
 const linkTitle = 'Umbraco Documentation';
-const manualPropertyName = 'Manual';
-const anchorOrQuerystringPropertyName = 'Anchor or querystring';
-const anchorValue = '#anchor';
-const querystringValue = '?param=value';
 let dataTypeData: any;
 let documentTypeId: any;
 
@@ -212,7 +208,7 @@ test('can add multiple links in the content', {tag: '@release'}, async ({umbraco
 
 test('can remove the URL picker in the content', async ({umbracoApi, umbracoUi}) => {
   // Arrange
-  await umbracoApi.document.createDocumentWithExternalLinkURLPicker(contentName, documentTypeId, link, linkTitle);
+  await umbracoApi.document.createDocumentWithExternalLinkURLPicker(contentName, documentTypeId, dataTypeName, link, linkTitle);
   await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
 
@@ -230,7 +226,7 @@ test('can remove the URL picker in the content', async ({umbracoApi, umbracoUi})
 test('can edit the URL picker in the content', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const updatedLinkTitle = 'Updated Umbraco Documentation';
-  await umbracoApi.document.createDocumentWithExternalLinkURLPicker(contentName, documentTypeId, link, linkTitle);
+  await umbracoApi.document.createDocumentWithExternalLinkURLPicker(contentName, documentTypeId, dataTypeName, link, linkTitle);
   await umbracoUi.goToBackOffice();
   await umbracoUi.content.goToSection(ConstantHelper.sections.content);
 
@@ -442,165 +438,4 @@ test('can select a media file inside a folder as a media link', async ({umbracoA
   // Clean
   await umbracoApi.media.ensureNameNotExists(mediaFolderName);
   await umbracoApi.media.ensureNameNotExists(mediaFileName);
-});
-
-test.describe('manual tab validation tests', () => {
-  test('cannot create content with empty manual url and anchor', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => {
-    // Arrange
-    await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-    await umbracoUi.goToBackOffice();
-    await umbracoUi.content.goToSection(ConstantHelper.sections.content);
-
-    // Act
-    await umbracoUi.content.goToContentWithName(contentName);
-    await umbracoUi.content.clickAddMultiURLPickerButton();
-    await umbracoUi.content.clickManualLinkButton();
-    await umbracoUi.content.enterLink('');
-    await umbracoUi.content.enterAnchorOrQuerystring('');
-    await umbracoUi.content.clickLinkPickerAddButton();
-
-    // Assert
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
-  });
-
-  test('can see validation message disappear when url is entered', async ({umbracoApi, umbracoUi}) => {
-    // Arrange
-    await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-    await umbracoUi.goToBackOffice();
-    await umbracoUi.content.goToSection(ConstantHelper.sections.content);
-
-    // Act
-    await umbracoUi.content.goToContentWithName(contentName);
-    await umbracoUi.content.clickAddMultiURLPickerButton();
-    await umbracoUi.content.clickManualLinkButton();
-    // Leave both fields empty first to trigger validation
-    await umbracoUi.content.enterLink('');
-    await umbracoUi.content.enterAnchorOrQuerystring('');
-    await umbracoUi.content.clickLinkPickerAddButton();
-    // Verify validation messages appear
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
-    // Enter URL to clear validation
-    await umbracoUi.content.enterLink(link);
-
-    // Assert
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker, false);
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker, false);
-  });
-
-  test('can see validation message disappear when anchor is entered', async ({umbracoApi, umbracoUi}) => {
-    // Arrange
-    await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-    await umbracoUi.goToBackOffice();
-    await umbracoUi.content.goToSection(ConstantHelper.sections.content);
-
-    // Act
-    await umbracoUi.content.goToContentWithName(contentName);
-    await umbracoUi.content.clickAddMultiURLPickerButton();
-    await umbracoUi.content.clickManualLinkButton();
-    // Leave both fields empty first to trigger validation
-    await umbracoUi.content.enterLink('');
-    await umbracoUi.content.enterAnchorOrQuerystring('');
-    await umbracoUi.content.clickLinkPickerAddButton();
-    // Verify validation messages appear
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
-    // Enter Anchor to clear validation
-    await umbracoUi.content.enterAnchorOrQuerystring(anchorValue);
-
-    // Assert
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker, false);
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker, false);
-  });
-
-  test('can create content with manual url only', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => {
-    // Arrange
-    await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-    await umbracoUi.goToBackOffice();
-    await umbracoUi.content.goToSection(ConstantHelper.sections.content);
-
-    // Act
-    await umbracoUi.content.goToContentWithName(contentName);
-    await umbracoUi.content.clickAddMultiURLPickerButton();
-    await umbracoUi.content.clickManualLinkButton();
-    await umbracoUi.content.enterLink(link);
-    // Leave Anchor empty
-    await umbracoUi.content.clickLinkPickerAddButton();
-    await umbracoUi.content.clickSaveButtonAndWaitForContentToBeUpdated();
-
-    // Assert
-    expect(await umbracoApi.document.doesNameExist(contentName)).toBeTruthy();
-    const contentData = await umbracoApi.document.getByName(contentName);
-    expect(contentData.values[0].alias).toEqual(AliasHelper.toAlias(dataTypeName));
-    expect(contentData.values[0].value.length).toBe(1);
-    expect(contentData.values[0].value[0].type).toEqual('external');
-    expect(contentData.values[0].value[0].url).toEqual(link);
-  });
-
-  test('can create content with manual anchor only', async ({umbracoApi, umbracoUi}) => {
-    // Arrange
-    await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-    await umbracoUi.goToBackOffice();
-    await umbracoUi.content.goToSection(ConstantHelper.sections.content);
-
-    // Act
-    await umbracoUi.content.goToContentWithName(contentName);
-    await umbracoUi.content.clickAddMultiURLPickerButton();
-    await umbracoUi.content.clickManualLinkButton();
-    // Leave URL empty
-    await umbracoUi.content.enterAnchorOrQuerystring(anchorValue);
-    await umbracoUi.content.clickLinkPickerAddButton();
-    await umbracoUi.content.clickSaveButtonAndWaitForContentToBeUpdated();
-
-    // Assert
-    expect(await umbracoApi.document.doesNameExist(contentName)).toBeTruthy();
-    const contentData = await umbracoApi.document.getByName(contentName);
-    expect(contentData.values[0].alias).toEqual(AliasHelper.toAlias(dataTypeName));
-    expect(contentData.values[0].value.length).toBe(1);
-    expect(contentData.values[0].value[0].queryString).toEqual(anchorValue);
-  });
-
-  test('can create content with manual url and anchor', async ({umbracoApi, umbracoUi}) => {
-    // Arrange
-    await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
-    await umbracoUi.goToBackOffice();
-    await umbracoUi.content.goToSection(ConstantHelper.sections.content);
-
-    // Act
-    await umbracoUi.content.goToContentWithName(contentName);
-    await umbracoUi.content.clickAddMultiURLPickerButton();
-    await umbracoUi.content.clickManualLinkButton();
-    await umbracoUi.content.enterLink(link);
-    await umbracoUi.content.enterAnchorOrQuerystring(querystringValue);
-    await umbracoUi.content.clickLinkPickerAddButton();
-    await umbracoUi.content.clickSaveButtonAndWaitForContentToBeUpdated();
-
-    // Assert
-    expect(await umbracoApi.document.doesNameExist(contentName)).toBeTruthy();
-    const contentData = await umbracoApi.document.getByName(contentName);
-    expect(contentData.values[0].alias).toEqual(AliasHelper.toAlias(dataTypeName));
-    expect(contentData.values[0].value.length).toBe(1);
-    expect(contentData.values[0].value[0].type).toEqual('external');
-    expect(contentData.values[0].value[0].url).toEqual(link);
-    expect(contentData.values[0].value[0].queryString).toEqual(querystringValue);
-  });
-
-  test('cannot update content with empty manual url and anchor', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => {
-    // Arrange
-    await umbracoApi.document.createDocumentWithExternalLinkURLPicker(contentName, documentTypeId, link, linkTitle);
-    await umbracoUi.goToBackOffice();
-    await umbracoUi.content.goToSection(ConstantHelper.sections.content);
-
-    // Act
-    await umbracoUi.content.goToContentWithName(contentName);
-    await umbracoUi.content.clickLinkWithName(linkTitle);
-    await umbracoUi.content.enterLink('');
-    await umbracoUi.content.enterAnchorOrQuerystring('');
-    await umbracoUi.content.clickUpdateButton();
-
-    // Assert
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
-    await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
-  });
-});
+});
\ No newline at end of file
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/MultiURLPicker/MandatoryMultiURLPicker.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/MultiURLPicker/MandatoryMultiURLPicker.spec.ts
new file mode 100644
index 000000000000..3499cb5daaf8
--- /dev/null
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/MultiURLPicker/MandatoryMultiURLPicker.spec.ts
@@ -0,0 +1,117 @@
+import { ConstantHelper, test, AliasHelper } from '@umbraco/acceptance-test-helpers';
+import {expect} from "@playwright/test";
+
+const mandatoryDataTypeName = 'MandatoryMultiUrlPicker';
+const contentName = 'TestContent';
+const documentTypeName = 'TestDocumentTypeForContent';
+const link = 'https://docs.umbraco.com';
+const linkTitle = 'Umbraco Documentation';
+const secondLink = 'https://umbraco.com';
+const secondLinkTitle = 'Umbraco';
+let mandatoryDataTypeId: any;
+let mandatoryDocumentTypeId: any;
+
+test.beforeEach(async ({umbracoApi, umbracoUi}) => {
+  mandatoryDataTypeId = await umbracoApi.dataType.createDefaultMultiUrlPickerDataType(mandatoryDataTypeName);
+  mandatoryDocumentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, mandatoryDataTypeName, mandatoryDataTypeId, 'TestGroup', false, false, true);
+  await umbracoUi.goToBackOffice();
+});
+
+test.afterEach(async ({umbracoApi}) => {
+  await umbracoApi.document.ensureNameNotExists(contentName);
+  await umbracoApi.documentType.ensureNameNotExists(documentTypeName);
+  await umbracoApi.dataType.ensureNameNotExists(mandatoryDataTypeName);
+});
+
+test('can save content with mandatory multi url picker after adding a link', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.document.createDefaultDocument(contentName, mandatoryDocumentTypeId);
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+
+  // Act
+  await umbracoUi.content.goToContentWithName(contentName);
+  await umbracoUi.content.clickSaveAndPublishButton();
+  await umbracoUi.content.isValidationMessageVisible(ConstantHelper.validationMessages.nullValue);
+  // Add a manual link
+  await umbracoUi.content.clickAddMultiURLPickerButton();
+  await umbracoUi.content.clickManualLinkButton();
+  await umbracoUi.content.enterLink(link);
+  await umbracoUi.content.enterLinkTitle(linkTitle);
+  await umbracoUi.content.clickLinkPickerAddButton();
+  await umbracoUi.content.clickSaveButtonAndWaitForContentToBeUpdated();
+
+  // Assert
+  await umbracoUi.content.isValidationMessageVisible(ConstantHelper.validationMessages.nullValue, false);
+  expect(await umbracoApi.document.doesNameExist(contentName)).toBeTruthy();
+  const contentData = await umbracoApi.document.getByName(contentName);
+  expect(contentData.values[0].alias).toEqual(AliasHelper.toAlias(mandatoryDataTypeName));
+  expect(contentData.values[0].value.length).toBe(1);
+  expect(contentData.values[0].value[0].type).toEqual('external');
+  expect(contentData.values[0].value[0].icon).toEqual('icon-link');
+  expect(contentData.values[0].value[0].name).toEqual(linkTitle);
+  expect(contentData.values[0].value[0].url).toEqual(link);
+});
+
+test('can see validation error after removing all links from mandatory multi url picker', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.document.createDocumentWithExternalLinkURLPicker(contentName, mandatoryDocumentTypeId, mandatoryDataTypeName, link, linkTitle);
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+
+  // Act
+  await umbracoUi.content.goToContentWithName(contentName);
+  await umbracoUi.content.removeUrlPickerByName(linkTitle);
+  await umbracoUi.content.clickSaveAndPublishButton();
+
+  // Assert
+  await umbracoUi.content.isValidationMessageVisible(ConstantHelper.validationMessages.emptyValue);
+  await umbracoUi.content.isErrorNotificationVisible();
+});
+
+test('can see validation error clear when minimum number of links is met', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const minNumberDataTypeName = 'MinNumberMultiUrlPicker';
+  const minNumberDataTypeId = await umbracoApi.dataType.createMultiUrlPickerDataTypeWithMinNumberOfItems(minNumberDataTypeName, 2);
+  const minNumberDocumentTypeName = 'MinNumberDocumentType';
+  const minNumberDocumentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(minNumberDocumentTypeName, minNumberDataTypeName, minNumberDataTypeId, 'TestGroup', false, false, true);
+  await umbracoApi.document.createDefaultDocument(contentName, minNumberDocumentTypeId);
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+
+  // Act
+  await umbracoUi.content.goToContentWithName(contentName);
+  // Add first link
+  await umbracoUi.content.clickAddMultiURLPickerButton();
+  await umbracoUi.content.clickManualLinkButton();
+  await umbracoUi.content.enterLink(link);
+  await umbracoUi.content.enterLinkTitle(linkTitle);
+  await umbracoUi.content.clickLinkPickerAddButton();
+  // Try to save with only 1 link (min is 2)
+  await umbracoUi.content.clickSaveAndPublishButton();
+  await umbracoUi.content.isValidationMessageVisible(ConstantHelper.validationMessages.needMoreItems);
+  // Add second link
+  await umbracoUi.waitForTimeout(ConstantHelper.wait.short);
+  await umbracoUi.content.clickAddMultiURLPickerButton();
+  await umbracoUi.content.clickManualLinkButton();
+  await umbracoUi.content.enterLink(secondLink);
+  await umbracoUi.content.enterLinkTitle(secondLinkTitle);
+  await umbracoUi.content.clickLinkPickerAddButton();
+  // Validation should clear
+  await umbracoUi.content.isValidationMessageVisible(ConstantHelper.validationMessages.needMoreItems, false);
+  await umbracoUi.content.clickSaveButtonAndWaitForContentToBeUpdated();
+
+  // Assert
+  const contentData = await umbracoApi.document.getByName(contentName);
+  expect(contentData.values[0].alias).toEqual(AliasHelper.toAlias(minNumberDataTypeName));
+  expect(contentData.values[0].value.length).toBe(2);
+  expect(contentData.values[0].value[0].type).toEqual('external');
+  expect(contentData.values[0].value[0].icon).toEqual('icon-link');
+  expect(contentData.values[0].value[0].name).toEqual(linkTitle);
+  expect(contentData.values[0].value[0].url).toEqual(link);
+  expect(contentData.values[0].value[1].type).toEqual('external');
+  expect(contentData.values[0].value[1].icon).toEqual('icon-link');
+  expect(contentData.values[0].value[1].name).toEqual(secondLinkTitle);
+  expect(contentData.values[0].value[1].url).toEqual(secondLink);
+
+  // Clean
+  await umbracoApi.documentType.ensureNameNotExists(minNumberDocumentTypeName);
+  await umbracoApi.dataType.ensureNameNotExists(minNumberDataTypeName);
+});
\ No newline at end of file
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/MultiURLPicker/ManualTabValidation.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/MultiURLPicker/ManualTabValidation.spec.ts
new file mode 100644
index 000000000000..7bd23ea37624
--- /dev/null
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Content/MultiURLPicker/ManualTabValidation.spec.ts
@@ -0,0 +1,181 @@
+import { ConstantHelper, test, AliasHelper } from '@umbraco/acceptance-test-helpers';
+import {expect} from "@playwright/test";
+
+const dataTypeName = 'Multi URL Picker';
+const contentName = 'TestContent';
+const documentTypeName = 'TestDocumentTypeForContent';
+const link = 'https://docs.umbraco.com';
+const linkTitle = 'Umbraco Documentation';
+const manualPropertyName = 'Manual';
+const anchorOrQuerystringPropertyName = 'Anchor or querystring';
+const anchorValue = '#anchor';
+const querystringValue = '?param=value';
+let dataTypeData: any;
+let documentTypeId: any;
+
+test.beforeEach(async ({umbracoApi}) => {
+  dataTypeData = await umbracoApi.dataType.getByName(dataTypeName);
+  documentTypeId = await umbracoApi.documentType.createDocumentTypeWithPropertyEditor(documentTypeName, dataTypeName, dataTypeData.id);
+});
+
+test.afterEach(async ({umbracoApi}) => {
+  await umbracoApi.document.ensureNameNotExists(contentName);
+  await umbracoApi.documentType.ensureNameNotExists(documentTypeName);
+});
+
+test('cannot create content with empty manual url and anchor', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.goToBackOffice();
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+
+  // Act
+  await umbracoUi.content.goToContentWithName(contentName);
+  await umbracoUi.content.clickAddMultiURLPickerButton();
+  await umbracoUi.content.clickManualLinkButton();
+  await umbracoUi.content.enterLink('');
+  await umbracoUi.content.enterAnchorOrQuerystring('');
+  await umbracoUi.content.clickLinkPickerAddButton();
+
+  // Assert
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
+});
+
+test('can see validation message disappear when url is entered', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.goToBackOffice();
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+
+  // Act
+  await umbracoUi.content.goToContentWithName(contentName);
+  await umbracoUi.content.clickAddMultiURLPickerButton();
+  await umbracoUi.content.clickManualLinkButton();
+  // Leave both fields empty first to trigger validation
+  await umbracoUi.content.enterLink('');
+  await umbracoUi.content.enterAnchorOrQuerystring('');
+  await umbracoUi.content.clickLinkPickerAddButton();
+  // Verify validation messages appear
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
+  // Enter URL to clear validation
+  await umbracoUi.content.enterLink(link);
+
+  // Assert
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker, false);
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker, false);
+});
+
+test('can see validation message disappear when anchor is entered', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.goToBackOffice();
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+
+  // Act
+  await umbracoUi.content.goToContentWithName(contentName);
+  await umbracoUi.content.clickAddMultiURLPickerButton();
+  await umbracoUi.content.clickManualLinkButton();
+  // Leave both fields empty first to trigger validation
+  await umbracoUi.content.enterLink('');
+  await umbracoUi.content.enterAnchorOrQuerystring('');
+  await umbracoUi.content.clickLinkPickerAddButton();
+  // Verify validation messages appear
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
+  // Enter Anchor to clear validation
+  await umbracoUi.content.enterAnchorOrQuerystring(anchorValue);
+
+  // Assert
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker, false);
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker, false);
+});
+
+test('can create content with manual url only', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.goToBackOffice();
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+
+  // Act
+  await umbracoUi.content.goToContentWithName(contentName);
+  await umbracoUi.content.clickAddMultiURLPickerButton();
+  await umbracoUi.content.clickManualLinkButton();
+  await umbracoUi.content.enterLink(link);
+  await umbracoUi.content.clickLinkPickerAddButton();
+  await umbracoUi.content.clickSaveButtonAndWaitForContentToBeUpdated();
+
+  // Assert
+  expect(await umbracoApi.document.doesNameExist(contentName)).toBeTruthy();
+  const contentData = await umbracoApi.document.getByName(contentName);
+  expect(contentData.values[0].alias).toEqual(AliasHelper.toAlias(dataTypeName));
+  expect(contentData.values[0].value.length).toBe(1);
+  expect(contentData.values[0].value[0].type).toEqual('external');
+  expect(contentData.values[0].value[0].url).toEqual(link);
+});
+
+test('can create content with manual anchor only', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.goToBackOffice();
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+
+  // Act
+  await umbracoUi.content.goToContentWithName(contentName);
+  await umbracoUi.content.clickAddMultiURLPickerButton();
+  await umbracoUi.content.clickManualLinkButton();
+  await umbracoUi.content.enterAnchorOrQuerystring(anchorValue);
+  await umbracoUi.content.clickLinkPickerAddButton();
+  await umbracoUi.content.clickSaveButtonAndWaitForContentToBeUpdated();
+
+  // Assert
+  expect(await umbracoApi.document.doesNameExist(contentName)).toBeTruthy();
+  const contentData = await umbracoApi.document.getByName(contentName);
+  expect(contentData.values[0].alias).toEqual(AliasHelper.toAlias(dataTypeName));
+  expect(contentData.values[0].value.length).toBe(1);
+  expect(contentData.values[0].value[0].queryString).toEqual(anchorValue);
+});
+
+test('can create content with manual url and anchor', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.document.createDefaultDocument(contentName, documentTypeId);
+  await umbracoUi.goToBackOffice();
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+
+  // Act
+  await umbracoUi.content.goToContentWithName(contentName);
+  await umbracoUi.content.clickAddMultiURLPickerButton();
+  await umbracoUi.content.clickManualLinkButton();
+  await umbracoUi.content.enterLink(link);
+  await umbracoUi.content.enterAnchorOrQuerystring(querystringValue);
+  await umbracoUi.content.clickLinkPickerAddButton();
+  await umbracoUi.content.clickSaveButtonAndWaitForContentToBeUpdated();
+
+  // Assert
+  expect(await umbracoApi.document.doesNameExist(contentName)).toBeTruthy();
+  const contentData = await umbracoApi.document.getByName(contentName);
+  expect(contentData.values[0].alias).toEqual(AliasHelper.toAlias(dataTypeName));
+  expect(contentData.values[0].value.length).toBe(1);
+  expect(contentData.values[0].value[0].type).toEqual('external');
+  expect(contentData.values[0].value[0].url).toEqual(link);
+  expect(contentData.values[0].value[0].queryString).toEqual(querystringValue);
+});
+
+test('cannot update content with empty manual url and anchor', {tag: '@release'}, async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.document.createDocumentWithExternalLinkURLPicker(contentName, documentTypeId, dataTypeName, link, linkTitle);
+  await umbracoUi.goToBackOffice();
+  await umbracoUi.content.goToSection(ConstantHelper.sections.content);
+
+  // Act
+  await umbracoUi.content.goToContentWithName(contentName);
+  await umbracoUi.content.clickLinkWithName(linkTitle);
+  await umbracoUi.content.enterLink('');
+  await umbracoUi.content.enterAnchorOrQuerystring('');
+  await umbracoUi.content.clickUpdateButton();
+
+  // Assert
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(manualPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
+  await umbracoUi.content.doesPropertyWithNameContainValidationMessage(anchorOrQuerystringPropertyName, ConstantHelper.validationMessages.emptyManualLinkPicker);
+});
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/BlockGrid/Block/BlockGridBlockAreas.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/BlockGrid/Block/BlockGridBlockAreas.spec.ts
index 0922d8533493..dd158e8629a9 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/BlockGrid/Block/BlockGridBlockAreas.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/BlockGrid/Block/BlockGridBlockAreas.spec.ts
@@ -3,6 +3,7 @@ import {expect} from "@playwright/test";
 
 const blockGridEditorName = 'TestBlockGridEditor';
 const elementTypeName = 'BlockGridElement';
+const secondElementTypeName = 'SecondBlockElement';
 const dataTypeName = 'Textstring';
 const groupName = 'testGroup';
 let contentElementTypeId = '';
@@ -17,6 +18,7 @@ test.beforeEach(async ({umbracoUi, umbracoApi}) => {
 test.afterEach(async ({umbracoApi}) => {
   await umbracoApi.dataType.ensureNameNotExists(blockGridEditorName);
   await umbracoApi.documentType.ensureNameNotExists(elementTypeName);
+  await umbracoApi.documentType.ensureNameNotExists(secondElementTypeName);
 });
 
 test('can update grid columns for areas for a block', async ({umbracoApi, umbracoUi}) => {
@@ -291,22 +293,119 @@ test('can add specified allowance for an area in a block', async ({umbracoApi, u
   expect(await umbracoApi.dataType.doesBlockEditorBlockContainAreaWithSpecifiedAllowance(blockGridEditorName, contentElementTypeId, areaAlias)).toBeTruthy();
 });
 
-test.fixme('can update specified allowance for an area in a block', async ({umbracoApi, umbracoUi}) => {
-  // TODO: Implement it later
+test('can update specified allowance for an area in a block', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const areaAlias = 'TestArea';
+  const textStringData = await umbracoApi.dataType.getByName(dataTypeName);
+  const secondContentElementTypeId = await umbracoApi.documentType.createDefaultElementType(secondElementTypeName, groupName, dataTypeName, textStringData.id);
+  await umbracoApi.dataType.createBlockGridWithAnAreaWithSpecifiedAllowanceInABlock(blockGridEditorName, contentElementTypeId, secondContentElementTypeId, areaAlias);
+  expect(await umbracoApi.dataType.doesBlockGridBlockContainAreaWithSpecifiedAllowanceForElementType(blockGridEditorName, contentElementTypeId, secondContentElementTypeId, areaAlias)).toBeTruthy();
+
+  // Act
+  await umbracoUi.dataType.goToDataType(blockGridEditorName);
+  await umbracoUi.dataType.goToBlockWithName(elementTypeName);
+  await umbracoUi.dataType.goToBlockAreasTab();
+  await umbracoUi.dataType.goToAreaByAlias(areaAlias);
+  await umbracoUi.dataType.clickSpecifiedAllowanceComboboxByIndex(0);
+  await umbracoUi.dataType.selectSpecifiedAllowanceOptionByName(elementTypeName);
+  await umbracoUi.dataType.clickAreaSubmitButton();
+  await umbracoUi.dataType.clickSubmitButton();
+  await umbracoUi.dataType.clickSaveButtonAndWaitForDataTypeToBeUpdated();
+
+  // Assert
+  expect(await umbracoApi.dataType.doesBlockGridBlockContainAreaWithSpecifiedAllowanceForElementType(blockGridEditorName, contentElementTypeId, contentElementTypeId, areaAlias)).toBeTruthy();
+  expect(await umbracoApi.dataType.doesBlockGridBlockContainAreaWithSpecifiedAllowanceForElementType(blockGridEditorName, contentElementTypeId, secondContentElementTypeId, areaAlias)).toBeFalsy();
 });
 
-test.fixme('can remove specified allowance for an area in a block', async ({umbracoApi, umbracoUi}) => {
-  // TODO: Implement it later
+test('can remove specified allowance for an area in a block', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const areaAlias = 'TestArea';
+  const textStringData = await umbracoApi.dataType.getByName(dataTypeName);
+  const secondContentElementTypeId = await umbracoApi.documentType.createDefaultElementType(secondElementTypeName, groupName, dataTypeName, textStringData.id);
+  await umbracoApi.dataType.createBlockGridWithAnAreaWithSpecifiedAllowanceInABlock(blockGridEditorName, contentElementTypeId, secondContentElementTypeId, areaAlias);
+  expect(await umbracoApi.dataType.doesBlockEditorBlockContainAreaWithSpecifiedAllowance(blockGridEditorName, contentElementTypeId, areaAlias)).toBeTruthy();
+
+  // Act
+  await umbracoUi.dataType.goToDataType(blockGridEditorName);
+  await umbracoUi.dataType.goToBlockWithName(elementTypeName);
+  await umbracoUi.dataType.goToBlockAreasTab();
+  await umbracoUi.dataType.goToAreaByAlias(areaAlias);
+  await umbracoUi.dataType.clickRemoveSpecifiedAllowanceByIndex(0);
+  await umbracoUi.dataType.clickAreaSubmitButton();
+  await umbracoUi.dataType.clickSubmitButton();
+  await umbracoUi.dataType.clickSaveButtonAndWaitForDataTypeToBeUpdated();
+
+  // Assert
+  expect(await umbracoApi.dataType.doesBlockEditorBlockContainAreaWithSpecifiedAllowance(blockGridEditorName, contentElementTypeId, areaAlias)).toBeFalsy();
 });
 
-test.fixme('can add multiple specified allowances for an area in a block', async ({umbracoApi, umbracoUi}) => {
-  // TODO: Implement it later
+test('can add multiple specified allowances for an area in a block', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const areaAlias = 'TestArea';
+  const textStringData = await umbracoApi.dataType.getByName(dataTypeName);
+  const secondContentElementTypeId = await umbracoApi.documentType.createDefaultElementType(secondElementTypeName, groupName, dataTypeName, textStringData.id);
+  await umbracoApi.dataType.createBlockGridWithAnAreaWithSpecifiedAllowanceInABlock(blockGridEditorName, contentElementTypeId, secondContentElementTypeId, areaAlias);
+  expect(await umbracoApi.dataType.doesBlockGridBlockContainAreaWithSpecifiedAllowanceCount(blockGridEditorName, contentElementTypeId, 1, areaAlias)).toBeTruthy();
+
+  // Act
+  await umbracoUi.dataType.goToDataType(blockGridEditorName);
+  await umbracoUi.dataType.goToBlockWithName(elementTypeName);
+  await umbracoUi.dataType.goToBlockAreasTab();
+  await umbracoUi.dataType.goToAreaByAlias(areaAlias);
+  await umbracoUi.dataType.clickAddSpecifiedAllowanceButton();
+  await umbracoUi.dataType.clickAreaSubmitButton();
+  await umbracoUi.dataType.clickSubmitButton();
+  await umbracoUi.dataType.clickSaveButtonAndWaitForDataTypeToBeUpdated();
+
+  // Assert
+  expect(await umbracoApi.dataType.doesBlockGridBlockContainAreaWithSpecifiedAllowanceCount(blockGridEditorName, contentElementTypeId, 2, areaAlias)).toBeTruthy();
 });
 
-test.fixme('can add specified allowance with min and max for an area in a block', async ({umbracoApi, umbracoUi}) => {
-  // TODO: Implement it later
+test('can add specified allowance with min and max for an area in a block', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const areaAlias = 'TestArea';
+  const minAllowed = 2;
+  const maxAllowed = 5;
+  const textStringData = await umbracoApi.dataType.getByName(dataTypeName);
+  const secondContentElementTypeId = await umbracoApi.documentType.createDefaultElementType(secondElementTypeName, groupName, dataTypeName, textStringData.id);
+  await umbracoApi.dataType.createBlockGridWithAnAreaWithSpecifiedAllowanceInABlock(blockGridEditorName, contentElementTypeId, secondContentElementTypeId, areaAlias);
+
+  // Act
+  await umbracoUi.dataType.goToDataType(blockGridEditorName);
+  await umbracoUi.dataType.goToBlockWithName(elementTypeName);
+  await umbracoUi.dataType.goToBlockAreasTab();
+  await umbracoUi.dataType.goToAreaByAlias(areaAlias);
+  await umbracoUi.dataType.enterSpecifiedAllowanceMinByIndex(minAllowed, 0);
+  await umbracoUi.dataType.enterSpecifiedAllowanceMaxByIndex(maxAllowed, 0);
+  await umbracoUi.dataType.clickAreaSubmitButton();
+  await umbracoUi.dataType.clickSubmitButton();
+  await umbracoUi.dataType.clickSaveButtonAndWaitForDataTypeToBeUpdated();
+
+  // Assert
+  expect(await umbracoApi.dataType.doesBlockGridBlockContainAreaWithSpecifiedAllowanceMinMax(blockGridEditorName, contentElementTypeId, secondContentElementTypeId, minAllowed, maxAllowed, areaAlias)).toBeTruthy();
 });
 
-test.fixme('can remove min and max from specified allowance for an area in a block', async ({umbracoApi, umbracoUi}) => {
-  // TODO: Implement it later
+test('can remove min and max from specified allowance for an area in a block', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const areaAlias = 'TestArea';
+  const minAllowed = 3;
+  const maxAllowed = 8;
+  const textStringData = await umbracoApi.dataType.getByName(dataTypeName);
+  const secondContentElementTypeId = await umbracoApi.documentType.createDefaultElementType(secondElementTypeName, groupName, dataTypeName, textStringData.id);
+  await umbracoApi.dataType.createBlockGridWithAnAreaWithSpecifiedAllowanceWithMinMaxInABlock(blockGridEditorName, contentElementTypeId, secondContentElementTypeId, minAllowed, maxAllowed, areaAlias);
+  expect(await umbracoApi.dataType.doesBlockGridBlockContainAreaWithSpecifiedAllowanceMinMax(blockGridEditorName, contentElementTypeId, secondContentElementTypeId, minAllowed, maxAllowed, areaAlias)).toBeTruthy();
+
+  // Act
+  await umbracoUi.dataType.goToDataType(blockGridEditorName);
+  await umbracoUi.dataType.goToBlockWithName(elementTypeName);
+  await umbracoUi.dataType.goToBlockAreasTab();
+  await umbracoUi.dataType.goToAreaByAlias(areaAlias);
+  await umbracoUi.dataType.enterSpecifiedAllowanceMinByIndex(undefined, 0);
+  await umbracoUi.dataType.enterSpecifiedAllowanceMaxByIndex(undefined, 0);
+  await umbracoUi.dataType.clickAreaSubmitButton();
+  await umbracoUi.dataType.clickSubmitButton();
+  await umbracoUi.dataType.clickSaveButtonAndWaitForDataTypeToBeUpdated();
+
+  // Assert
+  expect(await umbracoApi.dataType.doesBlockGridBlockContainAreaWithSpecifiedAllowanceMinMax(blockGridEditorName, contentElementTypeId, secondContentElementTypeId, minAllowed, maxAllowed, areaAlias)).toBeFalsy();
 });
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/BlockListEditor/BlockListBlocks.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/BlockListEditor/BlockListBlocks.spec.ts
index 6bd3e52d18c4..905ccf428d66 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/BlockListEditor/BlockListBlocks.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/BlockListEditor/BlockListBlocks.spec.ts
@@ -179,7 +179,7 @@ test('can add a background color to a block', async ({umbracoApi, umbracoUi}) =>
 test('can update a background color for a block', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const backgroundColor = '#ff0000';
-  const newBackgroundColor = '#ff4444';
+  const newBackgroundColor = '#ff4242';
   await umbracoApi.dataType.createBlockListWithBlockWithCatalogueAppearance(blockListEditorName, elementTypeId, backgroundColor);
   let blockData = await umbracoApi.dataType.getByName(blockListEditorName);
   expect(blockData.values[0].value[0].backgroundColor).toEqual(backgroundColor);
@@ -235,7 +235,7 @@ test('can add a icon color to a block', {tag: '@smoke'}, async ({umbracoApi, umb
 test('can update a icon color for a block', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const iconColor = '#ff0000';
-  const newIconColor = '#ff4444';
+  const newIconColor = '#ff4242';
   await umbracoApi.dataType.createBlockListWithBlockWithCatalogueAppearance(blockListEditorName, elementTypeId, '', iconColor);
   let blockData = await umbracoApi.dataType.getByName(blockListEditorName);
   expect(blockData.values[0].value[0].iconColor).toEqual(iconColor);
@@ -284,7 +284,6 @@ test.skip('can update a custom stylesheet for a block', async ({umbracoApi, umbr
   await umbracoApi.stylesheet.ensureNameNotExists(secondStylesheetName);
   await umbracoApi.stylesheet.createDefaultStylesheet(stylesheetName);
   await umbracoApi.stylesheet.createDefaultStylesheet(secondStylesheetName);
-  
 
   await umbracoApi.dataType.createBlockListWithBlockWithCatalogueAppearance(blockListEditorName, elementTypeId, '', '', encodedStylesheetPath);
   let blockData = await umbracoApi.dataType.getByName(blockListEditorName);
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Tiptap.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Tiptap.spec.ts
index 6acfe6437779..356113a26ce8 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Tiptap.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/DataType/Tiptap.spec.ts
@@ -229,6 +229,21 @@ test('can add a nested media folder as image upload folder', async ({umbracoApi,
   await umbracoApi.media.ensureNameNotExists(parentFolderName);
 });
 
+test('can add allowed media type', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const mediaTypeName = 'Image';
+  const mediaTypeData = await umbracoApi.mediaType.getByName(mediaTypeName);
+  await umbracoApi.dataType.createDefaultTiptapDataType(tipTapName);
+  await umbracoUi.dataType.goToDataType(tipTapName);
+
+  // Act
+  await umbracoUi.dataType.addAllowedMediaType(mediaTypeName);
+  await umbracoUi.dataType.clickSaveButtonAndWaitForDataTypeToBeUpdated();
+
+  // Assert
+  expect(await umbracoApi.dataType.doesDataTypeHaveValue(tipTapName, 'allowedMediaTypes', mediaTypeData.id)).toBeTruthy();
+});
+
 test('can enable ignore user start nodes', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   await umbracoApi.dataType.createDefaultTiptapDataType(tipTapName);
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/Element.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/Element.spec.ts
index 3fd25e6f0bbd..fc569d2e236c 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/Element.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/Element.spec.ts
@@ -41,7 +41,7 @@ test('can create empty element', async ({umbracoApi, umbracoUi}) => {
   await umbracoUi.library.isElementInTreeVisible(elementName);
 });
 
-test('can save and publish empty element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can save and publish empty element', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const expectedState = 'Published';
   await umbracoUi.goToBackOffice();
@@ -62,7 +62,7 @@ test('can save and publish empty element', {tag: '@smoke'}, async ({umbracoApi,
   expect(elementData.variants[0].state).toBe(expectedState);
 });
 
-test('can create element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test.skip('can create element', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   await umbracoUi.goToBackOffice();
   await umbracoUi.library.goToSection(ConstantHelper.sections.library);
@@ -101,7 +101,7 @@ test('can rename element', async ({umbracoApi, umbracoUi}) => {
   expect(updatedElementData.variants[0].name).toEqual(elementName);
 });
 
-test('can update element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can update element', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const wrongElementText = 'This is wrong test element text';
   elementId = await umbracoApi.element.createElementWithTextContent(elementName, elementTypeId, wrongElementText, dataTypeName);
@@ -118,7 +118,7 @@ test('can update element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
   expect(updatedElementData.values[0].value).toBe(elementText);
 });
 
-test('can unpublish element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can unpublish element', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   elementId = await umbracoApi.element.createElementWithTextContent(elementName, elementTypeId, elementText, dataTypeName);
   await umbracoApi.element.publish(elementId);
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolder.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolder.spec.ts
index a4becba73bc5..be5bca6a5972 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolder.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolder.spec.ts
@@ -21,7 +21,7 @@ test.afterEach(async ({umbracoApi}) => {
   await umbracoApi.documentType.ensureNameNotExists(elementTypeName);
 });
 
-test('can create an empty element folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test.skip('can create an empty element folder', async ({umbracoApi, umbracoUi}) => {
   // Act
   await umbracoUi.library.goToSection(ConstantHelper.sections.library);
   await umbracoUi.library.clickActionsMenuAtRoot();
@@ -35,7 +35,7 @@ test('can create an empty element folder', {tag: '@smoke'}, async ({umbracoApi,
   await umbracoUi.library.isElementInTreeVisible(elementFolderName);
 });
 
-test('can trash an element folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can trash an element folder', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   await umbracoApi.element.createDefaultElementFolder(elementFolderName);
 
@@ -93,7 +93,7 @@ test('can create an element folder in a folder', async ({umbracoApi, umbracoUi})
   await umbracoApi.element.ensureNameNotExists(childFolderName);
 });
 
-test('can create a folder in a folder in a folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test.skip('can create a folder in a folder in a folder', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const grandParentFolderName = 'GrandParentElementFolder';
   const parentFolderName = 'ParentElementFolder';
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolderBulkActions.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolderBulkActions.spec.ts
index f421520e281b..bc6e0e4698ca 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolderBulkActions.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementFolderBulkActions.spec.ts
@@ -29,7 +29,7 @@ test.afterEach(async ({umbracoApi}) => {
   await umbracoApi.documentType.ensureNameNotExists(elementTypeName);
 });
 
-test('can bulk publish elements in a folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can bulk publish elements in a folder', async ({umbracoApi, umbracoUi}) => {
   // Act
   await umbracoUi.library.selectElementWithNameInElementCollectionView(firstElementName);
   await umbracoUi.library.selectElementWithNameInElementCollectionView(secondElementName);
@@ -41,7 +41,7 @@ test('can bulk publish elements in a folder', {tag: '@smoke'}, async ({umbracoAp
   expect(await umbracoApi.element.isElementPublished(secondElementId)).toBeTruthy();
 });
 
-test('can bulk unpublish elements in a folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can bulk unpublish elements in a folder', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   await umbracoApi.element.publish(firstElementId);
   await umbracoApi.element.publish(secondElementId);
@@ -81,7 +81,7 @@ test('can bulk move elements to another folder', async ({umbracoApi, umbracoUi})
   await umbracoApi.element.ensureNameNotExists(targetFolderName);
 });
 
-test('can bulk trash elements in a folder', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can bulk trash elements in a folder', async ({umbracoApi, umbracoUi}) => {
   // Act
   await umbracoUi.library.selectElementWithNameInElementCollectionView(firstElementName);
   await umbracoUi.library.selectElementWithNameInElementCollectionView(secondElementName);
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementWithElementPicker.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementWithElementPicker.spec.ts
index 15de1ff0bcc7..7d90dd5c1e53 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementWithElementPicker.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/ElementWithElementPicker.spec.ts
@@ -67,7 +67,7 @@ test('can publish element with the element picker data type', async ({umbracoApi
   expect(elementData.values).toEqual([]);
 });
 
-test('can publish element with an element picker selected', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can publish element with an element picker selected', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const elementPickerDataTypeId = await umbracoApi.dataType.createDefaultElementPickerDataType(elementPickerDataTypeName);
   const elementTypeId = await umbracoApi.documentType.createElementTypeWithPropertyInTab(elementTypeName, 'TestTab', 'TestGroup', elementPickerDataTypeName, elementPickerDataTypeId);
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/RecycleBin.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/RecycleBin.spec.ts
index 7dcb2cd83923..7d9c8343b9a2 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/RecycleBin.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Library/RecycleBin.spec.ts
@@ -20,7 +20,7 @@ test.afterEach(async ({umbracoApi}) => {
   await umbracoApi.element.emptyRecycleBin();
 });
 
-test('can trash an element', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can trash an element', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   await umbracoApi.element.createDefaultElement(elementName, elementTypeId);
   expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy();
@@ -57,8 +57,7 @@ test('can trash an element folder with children', async ({umbracoApi, umbracoUi}
   await umbracoUi.library.isElementInTreeVisible(elementFolderName, false);
 });
 
-// Currently it returns an error when trying to empty the recycle bin
-test.fixme('can empty recycle bin', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can empty recycle bin', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const elementId = await umbracoApi.element.createDefaultElement(elementName, elementTypeId);
   await umbracoApi.element.moveToRecycleBin(elementId);
@@ -87,6 +86,18 @@ test('can see trashed element in recycle bin', async ({umbracoApi, umbracoUi}) =
   await umbracoUi.library.isItemVisibleInRecycleBin(elementName);
 });
 
+test('can see trashed element folder in recycle bin', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName);
+  await umbracoApi.element.moveToRecycleBin(elementFolderId, true);
+
+  // Act
+  await umbracoUi.library.goToSection(ConstantHelper.sections.library);
+
+  // Assert
+  await umbracoUi.library.isItemVisibleInRecycleBin(elementFolderName);
+});
+
 test('can delete element from recycle bin', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const elementId = await umbracoApi.element.createDefaultElement(elementName, elementTypeId);
@@ -103,8 +114,60 @@ test('can delete element from recycle bin', async ({umbracoApi, umbracoUi}) => {
   expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeFalsy();
 });
 
-// Unskip once the front-end is ready
-test.skip('can restore element from recycle bin', async ({umbracoApi, umbracoUi}) => {
+test('can delete element folder from recycle bin', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName);
+  await umbracoApi.element.moveToRecycleBin(elementFolderId, true);
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementFolderName)).toBeTruthy();
+  await umbracoUi.library.goToSection(ConstantHelper.sections.library);
+  await umbracoUi.library.isItemVisibleInRecycleBin(elementFolderName);
+
+  // Act
+  await umbracoUi.library.clickDeleteButtonForTrashedElememtWithName(elementFolderName);
+  await umbracoUi.library.clickConfirmToDeleteButtonAndWaitForElementToBeDeleted();
+
+  // Assert
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementFolderName)).toBeFalsy();
+});
+
+test('can delete element folder with children from recycle bin', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const folderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName);
+  await umbracoApi.element.createDefaultElementWithParent(elementName, elementTypeId, folderId);
+  await umbracoApi.element.moveToRecycleBin(folderId, true);
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementFolderName)).toBeTruthy();
+  await umbracoUi.library.goToSection(ConstantHelper.sections.library);
+  await umbracoUi.library.isItemVisibleInRecycleBin(elementFolderName);
+
+  // Act
+  await umbracoUi.library.clickDeleteButtonForTrashedElememtWithName(elementFolderName);
+  await umbracoUi.library.clickConfirmToDeleteButtonAndWaitForElementToBeDeleted();
+
+  // Assert
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementFolderName)).toBeFalsy();
+  expect(await umbracoApi.element.doesNameExist(elementName)).toBeFalsy();
+});
+
+test('can delete child element from recycle bin', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const folderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName);
+  const elementId = await umbracoApi.element.createDefaultElementWithParent(elementName, elementTypeId, folderId);
+  await umbracoApi.element.moveToRecycleBin(elementId);
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeTruthy();
+  await umbracoUi.library.goToSection(ConstantHelper.sections.library);
+  await umbracoUi.library.isItemVisibleInRecycleBin(elementName);
+
+  // Act
+  await umbracoUi.library.clickDeleteButtonForTrashedElememtWithName(elementName);
+  await umbracoUi.library.clickConfirmToDeleteButtonAndWaitForElementToBeDeleted();
+
+  // Assert
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeFalsy();
+  // Verify the parent folder still exists
+  expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeTruthy();
+});
+
+test('can restore element from recycle bin', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const elementId = await umbracoApi.element.createDefaultElement(elementName, elementTypeId);
   await umbracoApi.element.moveToRecycleBin(elementId);
@@ -115,6 +178,7 @@ test.skip('can restore element from recycle bin', async ({umbracoApi, umbracoUi}
   await umbracoUi.library.isItemVisibleInRecycleBin(elementName);
   await umbracoUi.library.clickActionsMenuForElement(elementName);
   await umbracoUi.library.clickRestoreActionMenuOption();
+  await umbracoUi.library.isRestoreFromRecycleBinMessageVisible(elementName, 'Root');
   await umbracoUi.library.clickRestoreButton();
 
   // Assert
@@ -124,3 +188,72 @@ test.skip('can restore element from recycle bin', async ({umbracoApi, umbracoUi}
   await umbracoUi.library.isElementInTreeVisible(elementName);
 });
 
+test('can restore element folder from recycle bin', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName);
+  await umbracoApi.element.moveToRecycleBin(elementFolderId, true);
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementFolderName)).toBeTruthy();
+
+  // Act
+  await umbracoUi.library.goToSection(ConstantHelper.sections.library);
+  await umbracoUi.library.isItemVisibleInRecycleBin(elementFolderName);
+  await umbracoUi.library.clickActionsMenuForElement(elementFolderName);
+  await umbracoUi.library.clickRestoreActionMenuOption();
+  await umbracoUi.library.isRestoreFromRecycleBinMessageVisible(elementFolderName, 'Root');
+  await umbracoUi.library.clickRestoreButton();
+
+  // Assert
+  await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.restored);
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementFolderName)).toBeFalsy();
+  expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeTruthy();
+  await umbracoUi.library.isElementInTreeVisible(elementFolderName);
+});
+
+test('can restore child element from recycle bin back to its parent folder', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const folderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName);
+  const elementId = await umbracoApi.element.createDefaultElementWithParent(elementName, elementTypeId, folderId);
+  await umbracoApi.element.moveToRecycleBin(elementId);
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeTruthy();
+  expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeTruthy();
+
+  // Act
+  await umbracoUi.library.goToSection(ConstantHelper.sections.library);
+  await umbracoUi.library.isItemVisibleInRecycleBin(elementName);
+  await umbracoUi.library.clickActionsMenuForElement(elementName);
+  await umbracoUi.library.clickRestoreActionMenuOption();
+  await umbracoUi.library.isRestoreFromRecycleBinMessageVisible(elementName, elementFolderName);
+  await umbracoUi.library.clickRestoreButton();
+
+  // Assert
+  await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.restored);
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementName)).toBeFalsy();
+  expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy();
+  // Verify the element is restored back under its parent folder
+  const children = await umbracoApi.element.getChildren(folderId);
+  expect(children.some(child => child.name === elementName)).toBeTruthy();
+});
+
+test('can restore element folder with children from recycle bin', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const folderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName);
+  await umbracoApi.element.createDefaultElementWithParent(elementName, elementTypeId, folderId);
+  await umbracoApi.element.moveToRecycleBin(folderId, true);
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementFolderName)).toBeTruthy();
+
+  // Act
+  await umbracoUi.library.goToSection(ConstantHelper.sections.library);
+  await umbracoUi.library.isItemVisibleInRecycleBin(elementFolderName);
+  await umbracoUi.library.clickActionsMenuForElement(elementFolderName);
+  await umbracoUi.library.clickRestoreActionMenuOption();
+  await umbracoUi.library.isRestoreFromRecycleBinMessageVisible(elementFolderName, 'Root');
+  await umbracoUi.library.clickRestoreButton();
+
+  // Assert
+  await umbracoUi.library.doesSuccessNotificationHaveText(NotificationConstantHelper.success.restored);
+  expect(await umbracoApi.element.doesItemExistInRecycleBin(elementFolderName)).toBeFalsy();
+  expect(await umbracoApi.element.doesNameExist(elementFolderName)).toBeTruthy();
+  expect(await umbracoApi.element.doesNameExist(elementName)).toBeTruthy();
+  await umbracoUi.library.isElementInTreeVisible(elementFolderName);
+});
+
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Media/Media.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Media/Media.spec.ts
index 335825e555df..b7e9ff53f35b 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Media/Media.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Media/Media.spec.ts
@@ -321,3 +321,43 @@ test('can bulk trash media nodes with a relation', async ({umbracoApi, umbracoUi
   await umbracoApi.documentType.ensureNameNotExists(documentPickerName2[1]);
   await umbracoApi.media.emptyRecycleBin();
 });
+
+test('can move a media item to a folder', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  await umbracoApi.media.createDefaultMediaFile(mediaFileName);
+  const mediaFolderId = await umbracoApi.media.createDefaultMediaFolder(folderName);
+  await umbracoUi.media.goToSection(ConstantHelper.sections.media);
+
+  // Act
+  await umbracoUi.media.clickActionsMenuForName(mediaFileName);
+  await umbracoUi.media.clickMoveToActionMenuOption();
+  await umbracoUi.media.openCaretButtonForName('Media', true);
+  await umbracoUi.media.clickModalTextByName(folderName);
+  await umbracoUi.media.clickChooseModalButtonAndWaitForMediaItemsToBeMoved(1);
+
+  // Assert
+  await umbracoUi.media.doesSuccessNotificationHaveText(NotificationConstantHelper.success.moved);
+  expect(await umbracoApi.media.doesMediaItemHaveChildName(mediaFolderId, mediaFileName)).toBeTruthy();
+
+  // Clean
+  await umbracoApi.media.ensureNameNotExists(folderName);
+});
+
+test('cannot move a media item to another media item', async ({umbracoApi, umbracoUi}) => {
+  // Arrange
+  const secondMediaFileName = 'SecondMediaFile';
+  await umbracoApi.media.createDefaultMediaFile(mediaFileName);
+  await umbracoApi.media.createDefaultMediaFile(secondMediaFileName);
+  await umbracoUi.media.goToSection(ConstantHelper.sections.media);
+
+  // Act
+  await umbracoUi.media.clickActionsMenuForName(mediaFileName);
+  await umbracoUi.media.clickMoveToActionMenuOption();
+  await umbracoUi.media.openCaretButtonForName('Media', true);
+
+  // Assert
+  await umbracoUi.media.isModalMenuItemWithNameDisabled(secondMediaFileName);
+
+  // Clean
+  await umbracoApi.media.ensureNameNotExists(secondMediaFileName);
+});
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInElement.spec.ts b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInElement.spec.ts
index ffe27ce233bd..d0a8723835dc 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInElement.spec.ts
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DefaultConfig/Users/Permissions/UserGroup/DefaultPermissionsInElement.spec.ts
@@ -42,7 +42,7 @@ test.afterEach(async ({umbracoApi}) => {
   await umbracoApi.element.emptyRecycleBin();
 });
 
-test('can read element with permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can read element with permission enabled', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   userGroupId = await umbracoApi.userGroup.createUserGroupWithReadElementPermission(userGroupName);
   await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId);
@@ -77,7 +77,7 @@ test.fixme('can not see element in tree with read permission disabled', async ({
 });
 
 // Currently user cannot choose element type to create element even with permission enabled
-test.fixme('can create element with create permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test.fixme('can create element with create permission enabled', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   userGroupId = await umbracoApi.userGroup.createUserGroupWithCreateElementPermission(userGroupName);
   await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId);
@@ -113,7 +113,7 @@ test('can not see create action menu with create permission disabled', async ({u
   await umbracoUi.library.isActionsMenuForNameVisible(elementName, false);
 });
 
-test('can trash element with delete permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can trash element with delete permission enabled', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   userGroupId = await umbracoApi.userGroup.createUserGroupWithDeleteElementPermission(userGroupName);
   await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId);
@@ -177,7 +177,7 @@ test('can not empty recycle bin with delete permission disabled', async ({umbrac
   await umbracoUi.library.isActionsMenuForRecycleBinVisible(false);
 });
 
-test('can publish element with publish permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can publish element with publish permission enabled', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   userGroupId = await umbracoApi.userGroup.createUserGroupWithPublishElementPermission(userGroupName);
   await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId);
@@ -208,7 +208,7 @@ test('can not publish element with publish permission disabled', async ({umbraco
   await umbracoUi.library.isActionsMenuForNameVisible(elementName, false);
 });
 
-test('can unpublish element with unpublish permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can unpublish element with unpublish permission enabled', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   await umbracoApi.element.publish(elementId);
   expect(await umbracoApi.element.isElementPublished(elementId)).toBeTruthy();
@@ -243,7 +243,7 @@ test('can not unpublish element with unpublish permission disabled', async ({umb
   await umbracoUi.library.isActionsMenuForNameVisible(elementName, false);
 });
 
-test('can update element with update permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can update element with update permission enabled', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   userGroupId = await umbracoApi.userGroup.createUserGroupWithUpdateElementPermission(userGroupName);
   await umbracoApi.user.setUserPermissions(testUser.name, testUser.email, testUser.password, userGroupId);
@@ -278,7 +278,7 @@ test.fixme('can not update element with update permission disabled', async ({umb
   await umbracoUi.library.isElementReadOnly(true);
 });
 
-test('can duplicate element with duplicate permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test('can duplicate element with duplicate permission enabled', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const duplicatedElementName = elementName + ' (1)';
   userGroupId = await umbracoApi.userGroup.createUserGroupWithDuplicateElementPermission(userGroupName);
@@ -320,7 +320,7 @@ test('can not duplicate element with duplicate permission disabled', async ({umb
   await umbracoUi.library.isActionsMenuForNameVisible(elementName, false);
 });
 
-test('can move element with move to permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test.skip('can move element with move to permission enabled', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   const elementFolderName = 'TestElementFolder';
   const elementFolderId = await umbracoApi.element.createDefaultElementFolder(elementFolderName);
@@ -367,7 +367,7 @@ test('can not move element with move to permission disabled', async ({umbracoApi
 });
 
 // Currently the rollback functionality in elements is not working.
-test.fixme('can rollback element with rollback permission enabled', {tag: '@smoke'}, async ({umbracoApi, umbracoUi}) => {
+test.fixme('can rollback element with rollback permission enabled', async ({umbracoApi, umbracoUi}) => {
   // Arrange
   userGroupId = await umbracoApi.userGroup.createUserGroupWithRollbackElementPermission(userGroupName);
   await umbracoApi.element.publish(elementId);
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/DeliveryApi/AdditionalSetup/appsettings.json b/tests/Umbraco.Tests.AcceptanceTest/tests/DeliveryApi/AdditionalSetup/appsettings.json
index 44dc8b93d27e..cc2ead83769b 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/DeliveryApi/AdditionalSetup/appsettings.json
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/DeliveryApi/AdditionalSetup/appsettings.json
@@ -53,9 +53,6 @@
           "Enabled": false
         }
       },
-      "KeepAlive": {
-        "DisableKeepAliveTask": true
-      },
       "WebRouting": {
         "UmbracoApplicationUrl": "https://localhost:44331/"
       }
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/EntityDataPicker/AdditionalSetup/appsettings.json b/tests/Umbraco.Tests.AcceptanceTest/tests/EntityDataPicker/AdditionalSetup/appsettings.json
index 49d90bb5936e..0b3f33d53457 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/EntityDataPicker/AdditionalSetup/appsettings.json
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/EntityDataPicker/AdditionalSetup/appsettings.json
@@ -47,9 +47,6 @@
           "Enabled": false
         }
       },
-      "KeepAlive": {
-        "DisableKeepAliveTask": true
-      },
       "WebRouting": {
         "UmbracoApplicationUrl": "https://localhost:44331/"
       }
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/ExtensionRegistry/AdditionalSetup/appsettings.json b/tests/Umbraco.Tests.AcceptanceTest/tests/ExtensionRegistry/AdditionalSetup/appsettings.json
index 49d90bb5936e..0b3f33d53457 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/ExtensionRegistry/AdditionalSetup/appsettings.json
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/ExtensionRegistry/AdditionalSetup/appsettings.json
@@ -47,9 +47,6 @@
           "Enabled": false
         }
       },
-      "KeepAlive": {
-        "DisableKeepAliveTask": true
-      },
       "WebRouting": {
         "UmbracoApplicationUrl": "https://localhost:44331/"
       }
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/ExternalLogin/AzureADB2C/AdditionalSetup/appsettings.json b/tests/Umbraco.Tests.AcceptanceTest/tests/ExternalLogin/AzureADB2C/AdditionalSetup/appsettings.json
index e978258b9a0f..1089bb9b9fad 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/ExternalLogin/AzureADB2C/AdditionalSetup/appsettings.json
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/ExternalLogin/AzureADB2C/AdditionalSetup/appsettings.json
@@ -47,9 +47,6 @@
           "Enabled": false
         }
       },
-      "KeepAlive": {
-        "DisableKeepAliveTask": true
-      },
       "WebRouting": {
         "UmbracoApplicationUrl": "https://localhost:44331/"
       }
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/ImagingSettingConfig/AdditionalSetup/appsettings.json b/tests/Umbraco.Tests.AcceptanceTest/tests/ImagingSettingConfig/AdditionalSetup/appsettings.json
index 682ef21118ec..1c7b468b24cc 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/ImagingSettingConfig/AdditionalSetup/appsettings.json
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/ImagingSettingConfig/AdditionalSetup/appsettings.json
@@ -47,9 +47,6 @@
           "Enabled": false
         }
       },
-      "KeepAlive": {
-        "DisableKeepAliveTask": true
-      },
       "WebRouting": {
         "UmbracoApplicationUrl": "https://localhost:44331/"
       }
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/SMTP/AdditionalSetup/appsettings.json b/tests/Umbraco.Tests.AcceptanceTest/tests/SMTP/AdditionalSetup/appsettings.json
index 0c280afb2536..b1bdefa5c0f0 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/SMTP/AdditionalSetup/appsettings.json
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/SMTP/AdditionalSetup/appsettings.json
@@ -53,9 +53,6 @@
           "Enabled": true
         }
       },
-      "KeepAlive": {
-        "DisableKeepAliveTask": true
-      },
       "WebRouting": {
         "UmbracoApplicationUrl": "https://localhost:44331/"
       }
diff --git a/tests/Umbraco.Tests.AcceptanceTest/tests/UnattendedInstallConfig/AdditionalSetup/appsettings.json b/tests/Umbraco.Tests.AcceptanceTest/tests/UnattendedInstallConfig/AdditionalSetup/appsettings.json
index 3aa310742c19..eeb2f24a345e 100644
--- a/tests/Umbraco.Tests.AcceptanceTest/tests/UnattendedInstallConfig/AdditionalSetup/appsettings.json
+++ b/tests/Umbraco.Tests.AcceptanceTest/tests/UnattendedInstallConfig/AdditionalSetup/appsettings.json
@@ -43,9 +43,6 @@
           "Enabled": false
         }
       },
-      "KeepAlive": {
-        "DisableKeepAliveTask": true
-      },
       "WebRouting": {
         "UmbracoApplicationUrl": "https://localhost:44331/"
       }
diff --git a/tests/Umbraco.Tests.Benchmarks/ContentTypeCachePolicyBenchmarks.cs b/tests/Umbraco.Tests.Benchmarks/ContentTypeCachePolicyBenchmarks.cs
new file mode 100644
index 000000000000..d261a391f19a
--- /dev/null
+++ b/tests/Umbraco.Tests.Benchmarks/ContentTypeCachePolicyBenchmarks.cs
@@ -0,0 +1,140 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using BenchmarkDotNet.Attributes;
+using Moq;
+using Umbraco.Cms.Core.Cache;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Infrastructure.Scoping;
+using Umbraco.Tests.Benchmarks.Config;
+using IScope = Umbraco.Cms.Infrastructure.Scoping.IScope;
+
+namespace Umbraco.Tests.Benchmarks;
+
+/// <summary>
+/// Benchmarks comparing the performance of <see cref="FullDataSetRepositoryCachePolicy{TEntity,TId}.FindCached"/>
+/// (clones only the matched entity) vs <see cref="FullDataSetRepositoryCachePolicy{TEntity,TId}.GetAll"/>
+/// (clones all cached entities then filters).
+/// </summary>
+/// <remarks>
+/// Run with: dotnet run -c Release --project tests/Umbraco.Tests.Benchmarks -- --filter "*ContentTypeCachePolicy*"
+/// </remarks>
+[QuickRunWithMemoryDiagnoserConfig]
+public class ContentTypeCachePolicyBenchmarks
+{
+    private FullDataSetRepositoryCachePolicy<AuditItem, object> _policy = null!;
+    private AuditItem[] _entities = null!;
+
+    [Params(10, 50, 200)]
+    public int EntityCount { get; set; }
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _entities = Enumerable.Range(1, EntityCount)
+            .Select(i => new AuditItem(i, AuditType.Copy, 123, "test", $"item{i}"))
+            .ToArray();
+
+        var accessor = new Mock<IScopeAccessor>();
+        var scope = new Mock<IScope>();
+        scope.Setup(x => x.RepositoryCacheMode).Returns(RepositoryCacheMode.Default);
+        accessor.Setup(x => x.AmbientScope).Returns(scope.Object);
+
+        var cache = new BenchmarkCache();
+
+        _policy = new FullDataSetRepositoryCachePolicy<AuditItem, object>(
+            cache,
+            accessor.Object,
+            new SingleServerCacheVersionService(),
+            Mock.Of<ICacheSyncService>(),
+            item => item.Id,
+            false);
+
+        // Warm the cache.
+        _policy.GetAll(null, _ => _entities);
+    }
+
+    /// <summary>
+    /// Baseline: simulates the old code path where GetAll() clones every entity,
+    /// then the caller filters with FirstOrDefault to find one.
+    /// </summary>
+    [Benchmark(Baseline = true)]
+    public AuditItem? GetAll_ThenFilter()
+    {
+        var all = _policy.GetAll(null, _ => _entities);
+        return all.FirstOrDefault(x => x.Id.Equals(EntityCount / 2));
+    }
+
+    /// <summary>
+    /// Optimized: FindCached searches non-cloned cache and clones only the single match.
+    /// </summary>
+    [Benchmark]
+    public AuditItem? FindCached_SingleClone()
+    {
+        return _policy.FindCached(x => x.Id.Equals(EntityCount / 2), _ => _entities);
+    }
+
+    /// <summary>
+    /// Optimized: ExistsCached searches non-cloned cache without cloning at all.
+    /// </summary>
+    [Benchmark]
+    public bool ExistsCached_NoClone()
+    {
+        return _policy.ExistsCached(x => x.Id.Equals(EntityCount / 2), _ => _entities);
+    }
+
+    /// <summary>
+    /// A simple cache backed by a dictionary, suitable for benchmarking.
+    /// </summary>
+    private sealed class BenchmarkCache : IAppPolicyCache
+    {
+        private readonly Dictionary<string, object?> _cache = [];
+
+        public object? Get(string key)
+            => _cache.TryGetValue(key, out var value) ? value : null;
+
+        public object? Get(string key, Func<object?> factory) => Get(key, factory, null, false);
+
+        public object? Get(string key, Func<object?> factory, TimeSpan? timeout, bool isSliding = false)
+        {
+            if (_cache.TryGetValue(key, out var value))
+            {
+                return value;
+            }
+
+            value = factory();
+            _cache[key] = value;
+            return value;
+        }
+
+        public IEnumerable<object> SearchByKey(string keyStartsWith)
+            => _cache.Where(kvp => kvp.Key.StartsWith(keyStartsWith, StringComparison.InvariantCultureIgnoreCase)).Select(kvp => kvp.Value!);
+
+        public IEnumerable<object> SearchByRegex(string regex) => throw new NotImplementedException();
+
+        public void Clear() => _cache.Clear();
+
+        public void Clear(string key) => _cache.Remove(key);
+
+        public void ClearOfType(Type type) => throw new NotImplementedException();
+
+        public void ClearOfType<T>() => throw new NotImplementedException();
+
+        public void ClearOfType<T>(Func<string, T, bool> predicate) => throw new NotImplementedException();
+
+        public void ClearByKey(string keyStartsWith)
+        {
+            var keysToRemove = _cache.Keys.Where(k => k.StartsWith(keyStartsWith, StringComparison.InvariantCultureIgnoreCase)).ToList();
+            foreach (var key in keysToRemove)
+            {
+                _cache.Remove(key);
+            }
+        }
+
+        public void ClearByRegex(string regex) => throw new NotImplementedException();
+
+        public void Insert(string key, Func<object?> factory, TimeSpan? timeout = null, bool isSliding = false)
+            => _cache[key] = factory();
+    }
+}
diff --git a/tests/Umbraco.Tests.Integration/ManagementApi/MemberGroup/Item/ItemMemberGroupItemControllerTests.cs b/tests/Umbraco.Tests.Integration/ManagementApi/MemberGroup/Item/ItemMemberGroupItemControllerTests.cs
index 7d3ec94862b3..95914e08e2fa 100644
--- a/tests/Umbraco.Tests.Integration/ManagementApi/MemberGroup/Item/ItemMemberGroupItemControllerTests.cs
+++ b/tests/Umbraco.Tests.Integration/ManagementApi/MemberGroup/Item/ItemMemberGroupItemControllerTests.cs
@@ -16,7 +16,7 @@ public class ItemMemberGroupItemControllerTests : ManagementApiUserGroupTestBase
     public async Task SetUp()
     {
         var memberGroup = new Core.Models.MemberGroup { Name = "Test Member Group" };
-        MemberGroupService.Save(memberGroup);
+        await MemberGroupService.CreateAsync(memberGroup);
         _memberGroupKey = memberGroup.Key;
     }
 
diff --git a/tests/Umbraco.Tests.Integration/Testing/UmbracoIntegrationTestWithContent.cs b/tests/Umbraco.Tests.Integration/Testing/UmbracoIntegrationTestWithContent.cs
index e8101d94140f..f2d4b6cd7717 100644
--- a/tests/Umbraco.Tests.Integration/Testing/UmbracoIntegrationTestWithContent.cs
+++ b/tests/Umbraco.Tests.Integration/Testing/UmbracoIntegrationTestWithContent.cs
@@ -2,6 +2,7 @@
 // See LICENSE for more details.
 
 using NUnit.Framework;
+using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Tests.Common.Builders;
@@ -24,6 +25,8 @@ public abstract class UmbracoIntegrationTestWithContent : UmbracoIntegrationTest
 
     protected IFileService FileService => GetRequiredService<IFileService>();
 
+    protected ITemplateService TemplateService => GetRequiredService<ITemplateService>();
+
     protected ContentService ContentService => (ContentService)GetRequiredService<IContentService>();
 
     protected Content Trashed { get; private set; }
@@ -38,13 +41,13 @@ public abstract class UmbracoIntegrationTestWithContent : UmbracoIntegrationTest
     protected ContentType ContentType { get; private set; }
 
     [SetUp]
-    public virtual void Setup() => CreateTestData();
+    public virtual async Task Setup() => await CreateTestDataAsync();
 
-    public virtual void CreateTestData()
+    public virtual async Task CreateTestDataAsync()
     {
         // NOTE Maybe not the best way to create/save test data as we are using the services, which are being tested.
         var template = TemplateBuilder.CreateTextPageTemplate("defaultTemplate");
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         // Create and Save ContentType "umbTextpage" -> 1051 (template), 1052 (content type)
         ContentType =
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Cache/ContentCacheRefresherStaleCacheInstructionTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Cache/ContentCacheRefresherStaleCacheInstructionTests.cs
index fba4be7b4a17..95e6fccc1f7c 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Cache/ContentCacheRefresherStaleCacheInstructionTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Cache/ContentCacheRefresherStaleCacheInstructionTests.cs
@@ -1,4 +1,5 @@
 using NUnit.Framework;
+using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Cache;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Notifications;
@@ -36,7 +37,7 @@ internal sealed class ContentCacheRefresherStaleCacheInstructionTests : UmbracoI
 
     private IMediaTypeService MediaTypeService => GetRequiredService<IMediaTypeService>();
 
-    private IFileService FileService => GetRequiredService<IFileService>();
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
 
     protected override void CustomTestSetup(IUmbracoBuilder builder)
     {
@@ -45,10 +46,10 @@ protected override void CustomTestSetup(IUmbracoBuilder builder)
         builder.AddNotificationHandler<MediaTreeChangeNotification, MediaTreeChangeDistributedCacheNotificationHandler>();
     }
 
-    private IContent CreateAndDeleteContent(string alias)
+    private async Task<IContent> CreateAndDeleteContent(string alias)
     {
         var template = TemplateBuilder.CreateTextPageTemplate(alias + "Template");
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(alias, alias, defaultTemplateId: template.Id);
         ContentTypeService.Save(contentType);
@@ -70,10 +71,10 @@ private IContent CreateAndDeleteContent(string alias)
     /// 3. Server processes the stale instruction on restart
     /// </summary>
     [Test]
-    public void ContentCacheRefresher_Handles_Stale_RefreshBranch_Instruction_For_Deleted_Content()
+    public async Task ContentCacheRefresher_Handles_Stale_RefreshBranch_Instruction_For_Deleted_Content()
     {
         // Arrange - Create and delete content
-        var content = CreateAndDeleteContent("testPage");
+        var content = await CreateAndDeleteContent("testPage");
 
         // Act - Simulate processing a stale RefreshBranch cache instruction
         // This is what happens when the server restarts and processes queued instructions
@@ -96,10 +97,10 @@ public void ContentCacheRefresher_Handles_Stale_RefreshBranch_Instruction_For_De
     /// for content that has been deleted.
     /// </summary>
     [Test]
-    public void ContentCacheRefresher_Handles_Stale_RefreshNode_Instruction_For_Deleted_Content()
+    public async Task ContentCacheRefresher_Handles_Stale_RefreshNode_Instruction_For_Deleted_Content()
     {
         // Arrange - Create and delete content
-        var content = CreateAndDeleteContent("testPage2");
+        var content = await CreateAndDeleteContent("testPage2");
 
         // Act - Simulate processing a stale RefreshNode cache instruction
         var stalePayload = new ContentCacheRefresher.JsonPayload
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Packaging/CreatedPackagesRepositoryTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Packaging/CreatedPackagesRepositoryTests.cs
index 25283be71cc7..1b8b3247450f 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Packaging/CreatedPackagesRepositoryTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Packaging/CreatedPackagesRepositoryTests.cs
@@ -61,6 +61,8 @@ public void DeleteTestFolder() =>
 
     private FileSystems FileSystems => GetRequiredService<FileSystems>();
 
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
+
     public ICreatedPackagesRepository PackageBuilder => new PackagesRepository(
         ContentService,
         ContentTypeService,
@@ -263,11 +265,11 @@ public void Export_Zip()
 
 
     [Test]
-    public void Export_Xml()
+    public async Task Export_Xml()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
 
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var def = new PackageDefinition { Name = "test", Templates = new[] { template.Id.ToString() } };
         var result = PackageBuilder.SavePackage(def);
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentServiceTests.cs
index 878bea7c612a..612c09c62192 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentServiceTests.cs
@@ -77,6 +77,8 @@ internal sealed partial class ContentServiceTests : UmbracoIntegrationTestWithCo
 
     private IValueEditorCache ValueEditorCache => GetRequiredService<IValueEditorCache>();
 
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
+
     protected override void CustomTestSetup(IUmbracoBuilder builder) => builder
         .AddNotificationHandler<ContentPublishingNotification, ContentNotificationHandler>()
         .AddNotificationHandler<ContentCopyingNotification, ContentNotificationHandler>()
@@ -84,10 +86,10 @@ protected override void CustomTestSetup(IUmbracoBuilder builder) => builder
         .AddNotificationHandler<ContentSavingNotification, ContentNotificationHandler>();
 
     [Test]
-    public void Create_Blueprint()
+    public async Task Create_Blueprint()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id);
         ContentTypeService.Save(contentType);
@@ -109,10 +111,10 @@ public void Create_Blueprint()
     }
 
     [Test]
-    public void Delete_Blueprint()
+    public async Task Delete_Blueprint()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id);
         ContentTypeService.Save(contentType);
@@ -132,12 +134,12 @@ public void Delete_Blueprint()
     }
 
     [Test]
-    public void Create_Blueprint_From_Content()
+    public async Task Create_Blueprint_From_Content()
     {
         using (var scope = ScopeProvider.CreateScope(autoComplete: true))
         {
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id);
             ContentTypeService.Save(contentType);
@@ -162,16 +164,16 @@ public void Create_Blueprint_From_Content()
 
     [Test]
     [LongRunning]
-    public void Get_All_Blueprints()
+    public async Task Get_All_Blueprints()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var ct1 = ContentTypeBuilder.CreateTextPageContentType("ct1", defaultTemplateId: template.Id);
-        FileService.SaveTemplate(ct1.DefaultTemplate);
+        await TemplateService.CreateAsync(ct1.DefaultTemplate, Constants.Security.SuperUserKey);
         ContentTypeService.Save(ct1);
         var ct2 = ContentTypeBuilder.CreateTextPageContentType("ct2", defaultTemplateId: template.Id);
-        FileService.SaveTemplate(ct2.DefaultTemplate);
+        await TemplateService.CreateAsync(ct2.DefaultTemplate, Constants.Security.SuperUserKey);
         ContentTypeService.Save(ct2);
 
         for (var i = 0; i < 10; i++)
@@ -400,11 +402,11 @@ public void Count_All()
     }
 
     [Test]
-    public void Count_By_Content_Type()
+    public async Task Count_By_Content_Type()
     {
         // Arrange
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbBlah", "test Doc Type", defaultTemplateId: template.Id);
@@ -421,11 +423,11 @@ public void Count_By_Content_Type()
     }
 
     [Test]
-    public void Count_Children()
+    public async Task Count_Children()
     {
         // Arrange
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbBlah", "test Doc Type", defaultTemplateId: template.Id);
@@ -443,11 +445,11 @@ public void Count_Children()
     }
 
     [Test]
-    public void Count_Descendants()
+    public async Task Count_Descendants()
     {
         // Arrange
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbBlah", "test Doc Type", defaultTemplateId: template.Id);
@@ -1280,10 +1282,10 @@ public void Can_Not_Publish_Invalid_Cultures_For_Invariant_Content()
     }
 
     [Test]
-    public void Can_Publish_Only_Valid_Content()
+    public async Task Can_Publish_Only_Valid_Content()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -1791,10 +1793,10 @@ public void Can_Save_Content()
     }
 
     [Test]
-    public void Can_Update_Content_Property_Values()
+    public async Task Can_Update_Content_Property_Values()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         IContentType contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         ContentTypeService.Save(contentType);
@@ -1984,7 +1986,7 @@ public async Task Ensures_Permissions_Are_Retained_For_Copied_Descendants_With_E
         await UserGroupService.CreateAsync(userGroup, Constants.Security.SuperUserKey);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbTextpage1", "Textpage", defaultTemplateId: template.Id);
@@ -2025,7 +2027,7 @@ public async Task Ensures_Permissions_Are_Inherited_For_Copied_Descendants()
         await UserGroupService.CreateAsync(userGroup, Constants.Security.SuperUserKey);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbTextpage1", "Textpage", defaultTemplateId: template.Id);
@@ -2213,7 +2215,7 @@ public void Can_Copy_Content()
     }
 
     [Test]
-    public void Can_Copy_And_Modify_Content_With_Events()
+    public async Task Can_Copy_And_Modify_Content_With_Events()
     {
         // see https://github.com/umbraco/Umbraco-CMS/issues/5513
 
@@ -2242,7 +2244,7 @@ public void Can_Copy_And_Modify_Content_With_Events()
         try
         {
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
             ContentTypeService.Save(contentType);
@@ -2308,14 +2310,14 @@ public void Can_Copy_NonRecursive()
     }
 
     [Test]
-    public void Can_Copy_Content_With_Tags()
+    public async Task Can_Copy_Content_With_Tags()
     {
         const string propAlias = "tags";
 
         // create a content type that has a 'tags' property
         // the property needs to support tags, else nothing works of course!
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType =
             ContentTypeBuilder.CreateSimpleTagsContentType(
                 "umbTagsPage",
@@ -2508,7 +2510,7 @@ public async Task Can_Rollback_Version_On_Multilingual()
         await LanguageService.CreateAsync(langDa, Constants.Security.SuperUserKey);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("multi", "Multi", defaultTemplateId: template.Id);
@@ -2824,14 +2826,14 @@ public void Can_Delete_Previous_Versions_Not_Latest()
 
     [Test]
     [LongRunning]
-    public void Can_Get_Paged_Children()
+    public async Task Can_Get_Paged_Children()
     {
         // Start by cleaning the "db"
         var umbTextPage = ContentService.GetById(new Guid("B58B3AD4-62C2-4E27-B1BE-837BD7C533E0"));
         ContentService.Delete(umbTextPage);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         ContentTypeService.Save(contentType);
@@ -2851,14 +2853,14 @@ public void Can_Get_Paged_Children()
 
     [Test]
     [LongRunning]
-    public void Can_Get_Paged_Children_Dont_Get_Descendants()
+    public async Task Can_Get_Paged_Children_Dont_Get_Descendants()
     {
         // Start by cleaning the "db"
         var umbTextPage = ContentService.GetById(new Guid("B58B3AD4-62C2-4E27-B1BE-837BD7C533E0"));
         ContentService.Delete(umbTextPage);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         ContentTypeService.Save(contentType);
@@ -2896,10 +2898,10 @@ public void Can_Get_Paged_Children_Dont_Get_Descendants()
     }
 
     [Test]
-    public void GetPagedChildren_With_Null_PropertyAliases_Returns_All_Properties()
+    public async Task GetPagedChildren_With_Null_PropertyAliases_Returns_All_Properties()
     {
         // Arrange
-        var parentId = CreateContentWithChildForGetPagedChildrenParameterTests();
+        var parentId = await CreateContentWithChildForGetPagedChildrenParameterTests();
 
         // Act - null propertyAliases should load all properties
         var retrievedChild = GetSingleChildWithPropertyAliases(parentId, propertyAliases: null);
@@ -2911,10 +2913,10 @@ public void GetPagedChildren_With_Null_PropertyAliases_Returns_All_Properties()
     }
 
     [Test]
-    public void GetPagedChildren_With_Empty_PropertyAliases_Returns_No_Property_Values()
+    public async Task GetPagedChildren_With_Empty_PropertyAliases_Returns_No_Property_Values()
     {
         // Arrange
-        var parentId = CreateContentWithChildForGetPagedChildrenParameterTests();
+        var parentId = await CreateContentWithChildForGetPagedChildrenParameterTests();
 
         // Act - empty propertyAliases should load no custom properties
         var retrievedChild = GetSingleChildWithPropertyAliases(parentId, propertyAliases: []);
@@ -2926,10 +2928,10 @@ public void GetPagedChildren_With_Empty_PropertyAliases_Returns_No_Property_Valu
     }
 
     [Test]
-    public void GetPagedChildren_With_Single_PropertyAlias_Returns_Only_That_Property()
+    public async Task GetPagedChildren_With_Single_PropertyAlias_Returns_Only_That_Property()
     {
         // Arrange
-        var parentId = CreateContentWithChildForGetPagedChildrenParameterTests();
+        var parentId = await CreateContentWithChildForGetPagedChildrenParameterTests();
 
         // Act - only "title" should be loaded
         var retrievedChild = GetSingleChildWithPropertyAliases(parentId, propertyAliases: ["title"]);
@@ -2941,10 +2943,10 @@ public void GetPagedChildren_With_Single_PropertyAlias_Returns_Only_That_Propert
     }
 
     [Test]
-    public void GetPagedChildren_With_Multiple_PropertyAliases_Returns_Only_Those_Properties()
+    public async Task GetPagedChildren_With_Multiple_PropertyAliases_Returns_Only_Those_Properties()
     {
         // Arrange
-        var parentId = CreateContentWithChildForGetPagedChildrenParameterTests();
+        var parentId = await CreateContentWithChildForGetPagedChildrenParameterTests();
 
         // Act - "title" and "author" should be loaded, but not "bodyText"
         var retrievedChild = GetSingleChildWithPropertyAliases(parentId, propertyAliases: ["title", "author"]);
@@ -2956,10 +2958,10 @@ public void GetPagedChildren_With_Multiple_PropertyAliases_Returns_Only_Those_Pr
     }
 
     [Test]
-    public void GetPagedChildren_With_NonExistent_PropertyAlias_Returns_No_Properties()
+    public async Task GetPagedChildren_With_NonExistent_PropertyAlias_Returns_No_Properties()
     {
         // Arrange
-        var parentId = CreateContentWithChildForGetPagedChildrenParameterTests();
+        var parentId = await CreateContentWithChildForGetPagedChildrenParameterTests();
 
         // Act - non-existent property alias should result in no property values
         var retrievedChild = GetSingleChildWithPropertyAliases(parentId, propertyAliases: ["nonExistentProperty"]);
@@ -2972,10 +2974,10 @@ public void GetPagedChildren_With_NonExistent_PropertyAlias_Returns_No_Propertie
     }
 
     [Test]
-    public void GetPagedChildren_With_LoadTemplates_True_Loads_Template()
+    public async Task GetPagedChildren_With_LoadTemplates_True_Loads_Template()
     {
         // Arrange
-        var parentId = CreateContentWithChildForGetPagedChildrenParameterTests();
+        var parentId = await CreateContentWithChildForGetPagedChildrenParameterTests();
 
         // Act - loadTemplates: true (default) should load templates
         var retrievedChild = GetSingleChildWithLoadTemplates(parentId, loadTemplates: true);
@@ -2985,10 +2987,10 @@ public void GetPagedChildren_With_LoadTemplates_True_Loads_Template()
     }
 
     [Test]
-    public void GetPagedChildren_With_LoadTemplates_False_Does_Not_Load_Template()
+    public async Task GetPagedChildren_With_LoadTemplates_False_Does_Not_Load_Template()
     {
         // Arrange
-        var parentId = CreateContentWithChildForGetPagedChildrenParameterTests();
+        var parentId = await CreateContentWithChildForGetPagedChildrenParameterTests();
 
         // Act - loadTemplates: false should not load templates
         var retrievedChild = GetSingleChildWithLoadTemplates(parentId, loadTemplates: false);
@@ -2998,10 +3000,10 @@ public void GetPagedChildren_With_LoadTemplates_False_Does_Not_Load_Template()
     }
 
     [Test]
-    public void GetPagedChildren_Default_LoadTemplates_Loads_Template()
+    public async Task GetPagedChildren_Default_LoadTemplates_Loads_Template()
     {
         // Arrange
-        var parentId = CreateContentWithChildForGetPagedChildrenParameterTests();
+        var parentId = await CreateContentWithChildForGetPagedChildrenParameterTests();
 
         // Act - default (no loadTemplates specified) should load templates (backwards compatible)
         var children = ContentService.GetPagedChildren(parentId, 0, 10, out var total, propertyAliases: null, filter: null, ordering: null).ToArray();
@@ -3016,10 +3018,10 @@ public void GetPagedChildren_Default_LoadTemplates_Loads_Template()
     /// Creates a content type with properties (title, bodyText, author) and a parent with one child.
     /// Returns the parent ID for use in GetPagedChildren tests.
     /// </summary>
-    private int CreateContentWithChildForGetPagedChildrenParameterTests()
+    private async Task<int> CreateContentWithChildForGetPagedChildrenParameterTests()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         ContentTypeService.Save(contentType);
@@ -3062,7 +3064,7 @@ private IContent GetSingleChildWithLoadTemplates(int parentId, bool loadTemplate
     }
 
     [Test]
-    public void PublishingTest()
+    public async Task PublishingTest()
     {
         var contentType = new ContentType(ShortStringHelper, Constants.System.Root) { Alias = "foo", Name = "Foo" };
 
@@ -3077,7 +3079,7 @@ public void PublishingTest()
         contentType.PropertyGroups.Add(new PropertyGroup(properties) { Alias = "content", Name = "content" });
 
         contentType.SetDefaultTemplate(new Template(ShortStringHelper, "Textpage", "textpage"));
-        FileService.SaveTemplate(contentType.DefaultTemplate); // else, FK violation on contentType!
+        await TemplateService.CreateAsync(contentType.DefaultTemplate, Constants.Security.SuperUserKey); // else, FK violation on contentType!
         ContentTypeService.Save(contentType);
 
         var content = ContentService.Create("foo", Constants.System.Root, "foo");
@@ -4125,7 +4127,7 @@ public class ContentNotificationHandler :
         await LanguageService.CreateAsync(langDa, Constants.Security.SuperUserKey);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = new ContentTypeBuilder()
             .WithAlias("variantContent")
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentTypeEditingServiceTests.ChangeTypes.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentTypeEditingServiceTests.ChangeTypes.cs
new file mode 100644
index 000000000000..dcb75128793c
--- /dev/null
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentTypeEditingServiceTests.ChangeTypes.cs
@@ -0,0 +1,484 @@
+using NUnit.Framework;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Cache;
+using Umbraco.Cms.Core.Models.ContentTypeEditing;
+using Umbraco.Cms.Core.Services.Changes;
+
+namespace Umbraco.Cms.Tests.Integration.Umbraco.Core.Services;
+
+/// <summary>
+///     Integration tests for granular <see cref="ContentTypeChangeTypes"/> flags emitted
+///     by content type editing operations.
+/// </summary>
+internal sealed partial class ContentTypeEditingServiceTests
+{
+    [Test]
+    public async Task Change_Alias_Emits_AliasChanged()
+    {
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Test", "test"), Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        var updateModel = ContentTypeUpdateModel("Test", "testRenamed");
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.AliasChanged), "Expected AliasChanged flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "AliasChanged should include RefreshMain");
+        });
+    }
+
+    [Test]
+    public async Task Change_Property_Alias_Via_EditingService_Emits_PropertyRemoved()
+    {
+        // NOTE: The editing service looks up existing properties by alias, so changing a property alias
+        // results in the old property being removed and a new one being created. This triggers
+        // PropertyRemoved rather than PropertyAliasChanged. The PropertyAliasChanged flag would fire
+        // when a property type's alias is changed in-place via the lower-level ContentTypeService.
+        var container = ContentTypePropertyContainerModel();
+        var propertyType = ContentTypePropertyTypeModel("Title", "title", containerKey: container.Key);
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Test", "test", propertyTypes: [propertyType], containers: [container]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        // Update the property with a different alias but same key — the editing service treats this
+        // as removing the old property and adding a new one
+        var updatedPropertyType = ContentTypePropertyTypeModel("Title", "titleRenamed", key: propertyType.Key, containerKey: container.Key);
+        var updateModel = ContentTypeUpdateModel("Test", "test", propertyTypes: [updatedPropertyType], containers: [container]);
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.PropertyRemoved), "Expected PropertyRemoved flag (old property removed)");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "PropertyRemoved should include RefreshMain");
+        });
+    }
+
+    [Test]
+    public async Task Change_Property_Alias_InPlace_Emits_PropertyAliasChanged()
+    {
+        // Test via the lower-level ContentTypeService where the property alias is changed in-place
+        var container = ContentTypePropertyContainerModel();
+        var propertyType = ContentTypePropertyTypeModel("Title", "title", containerKey: container.Key);
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Test", "test", propertyTypes: [propertyType], containers: [container]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        // Modify the alias in-place on the existing property type object
+        var existingProperty = contentType.PropertyTypes.Single();
+        existingProperty.Alias = "titleRenamed";
+        ContentTypeService.Save(contentType);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.PropertyAliasChanged), "Expected PropertyAliasChanged flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "PropertyAliasChanged should include RefreshMain");
+        });
+    }
+
+    [Test]
+    public async Task Remove_Property_Emits_PropertyRemoved()
+    {
+        var container = ContentTypePropertyContainerModel();
+        var propertyType = ContentTypePropertyTypeModel("Title", "title", containerKey: container.Key);
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Test", "test", propertyTypes: [propertyType], containers: [container]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        var updateModel = ContentTypeUpdateModel("Test", "test", propertyTypes: [], containers: [container]);
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.PropertyRemoved), "Expected PropertyRemoved flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "PropertyRemoved should include RefreshMain");
+            Assert.IsFalse(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.AliasChanged), "Should not have AliasChanged");
+        });
+    }
+
+    [Test]
+    public async Task Remove_Composition_Emits_CompositionRemoved()
+    {
+        var compositionProperty = ContentTypePropertyTypeModel("Comp Property", "compProperty");
+        var compositionType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Composition", "composition", propertyTypes: [compositionProperty]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        var ownProperty = ContentTypePropertyTypeModel("Own Property", "ownProperty");
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel(
+                "Test",
+                "test",
+                propertyTypes: [ownProperty],
+                compositions: [new Composition { Key = compositionType.Key, CompositionType = CompositionType.Composition }]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        var updateModel = ContentTypeUpdateModel("Test", "test", propertyTypes: [ownProperty], compositions: []);
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.CompositionRemoved), "Expected CompositionRemoved flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "CompositionRemoved should include RefreshMain");
+            Assert.IsFalse(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.PropertyRemoved), "Should not have PropertyRemoved");
+        });
+    }
+
+    [Test]
+    public async Task Change_Property_Variation_Emits_PropertyVariationChanged()
+    {
+        var container = ContentTypePropertyContainerModel();
+        var propertyType = ContentTypePropertyTypeModel("Title", "title", containerKey: container.Key);
+
+        var createModel = ContentTypeCreateModel("Test", "test", propertyTypes: [propertyType], containers: [container]);
+        createModel.VariesByCulture = true;
+        var contentType = (await ContentTypeEditingService.CreateAsync(createModel, Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        // Change the property to vary by culture
+        var updatedPropertyType = ContentTypePropertyTypeModel("Title", "title", containerKey: container.Key);
+        updatedPropertyType.VariesByCulture = true;
+        var updateModel = ContentTypeUpdateModel("Test", "test", propertyTypes: [updatedPropertyType], containers: [container]);
+        updateModel.VariesByCulture = true;
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.PropertyVariationChanged), "Expected PropertyVariationChanged flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "PropertyVariationChanged should include RefreshMain");
+            Assert.IsFalse(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.VariationChanged), "Should not have VariationChanged (content type variation did not change)");
+        });
+    }
+
+    [Test]
+    public async Task Change_ContentType_Variation_Emits_VariationChanged_And_RefreshMain()
+    {
+        var createModel = ContentTypeCreateModel("Test", "test");
+        createModel.VariesByCulture = false;
+        var contentType = (await ContentTypeEditingService.CreateAsync(createModel, Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        var updateModel = ContentTypeUpdateModel("Test", "test");
+        updateModel.VariesByCulture = true;
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.VariationChanged), "Expected VariationChanged flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "Should include RefreshMain");
+        });
+    }
+
+    [Test]
+    public async Task Multiple_Structural_Changes_Emit_Combined_Flags()
+    {
+        var container = ContentTypePropertyContainerModel();
+        var propertyType = ContentTypePropertyTypeModel("Title", "title", containerKey: container.Key);
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Test", "test", propertyTypes: [propertyType], containers: [container]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        // Change the alias AND remove the property in the same update
+        var updateModel = ContentTypeUpdateModel("Test", "testRenamed", propertyTypes: [], containers: [container]);
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.AliasChanged), "Expected AliasChanged flag");
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.PropertyRemoved), "Expected PropertyRemoved flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "Should include RefreshMain");
+        });
+    }
+
+    [Test]
+    public async Task Non_Structural_Change_Emits_RefreshOther_Without_RefreshMain()
+    {
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Test", "test"), Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        // Change only basic metadata (name, description, icon)
+        var updateModel = ContentTypeUpdateModel("Test Updated", "test");
+        updateModel.Description = "Updated description";
+        updateModel.Icon = "icon icon-updated";
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshOther), "Should include RefreshOther");
+            Assert.IsFalse(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "Should NOT include RefreshMain");
+        });
+    }
+
+    [Test]
+    public async Task Create_Emits_Create_Flag_Only()
+    {
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        var result = await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Test", "test"), Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.AreEqual(ContentTypeChangeTypes.Create, payload.ChangeTypes);
+            Assert.IsFalse(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "Create should not include RefreshMain");
+            Assert.IsFalse(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshOther), "Create should not include RefreshOther");
+        });
+    }
+
+    [Test]
+    public async Task Remove_Composition_From_Parent_Propagates_RefreshMain_To_Child()
+    {
+        var compositionProperty = ContentTypePropertyTypeModel("Comp Property", "compProperty");
+        var compositionType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Composition", "composition", propertyTypes: [compositionProperty]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        var parentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel(
+                "Parent",
+                "parent",
+                compositions: [new Composition { Key = compositionType.Key, CompositionType = CompositionType.Composition }]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        var childType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel(
+                "Child",
+                "child",
+                compositions: [new Composition { Key = parentType.Key, CompositionType = CompositionType.Inheritance }]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        // Remove the composition from the parent
+        var updateModel = ContentTypeUpdateModel("Parent", "parent", compositions: []);
+        var result = await ContentTypeEditingService.UpdateAsync(parentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(2, refreshedPayloads!.Length);
+
+        // Parent should have CompositionRemoved
+        var parentPayload = refreshedPayloads.Single(p => p.Id == parentType.Id);
+        Assert.IsTrue(parentPayload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.CompositionRemoved), "Parent should have CompositionRemoved");
+
+        // Child should have RefreshMain (propagated from parent's structural change)
+        var childPayload = refreshedPayloads.Single(p => p.Id == childType.Id);
+        Assert.IsTrue(childPayload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "Child should have RefreshMain (propagated)");
+    }
+
+    [Test]
+    public async Task Remove_Property_And_Add_Property_Emits_Both_Flags()
+    {
+        var container = ContentTypePropertyContainerModel();
+        var propertyType = ContentTypePropertyTypeModel("Title", "title", containerKey: container.Key);
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Test", "test", propertyTypes: [propertyType], containers: [container]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        // Remove the old property and add a new one in the same update
+        var newPropertyType = ContentTypePropertyTypeModel("Subtitle", "subtitle", containerKey: container.Key);
+        var updateModel = ContentTypeUpdateModel("Test", "test", propertyTypes: [newPropertyType], containers: [container]);
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.PropertyRemoved), "Expected PropertyRemoved flag");
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.PropertyAdded), "Expected PropertyAdded flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "PropertyRemoved should include RefreshMain");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshOther), "PropertyAdded should include RefreshOther");
+        });
+    }
+
+    [Test]
+    public async Task Remove_Composition_And_Add_Composition_Emits_Both_Flags()
+    {
+        var compositionA = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("CompositionA", "compositionA",
+                propertyTypes: [ContentTypePropertyTypeModel("Prop A", "propA")]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        var compositionB = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("CompositionB", "compositionB",
+                propertyTypes: [ContentTypePropertyTypeModel("Prop B", "propB")]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel(
+                "Test",
+                "test",
+                compositions: [new Composition { Key = compositionA.Key, CompositionType = CompositionType.Composition }]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        // Remove compositionA and add compositionB in the same update
+        var updateModel = ContentTypeUpdateModel(
+            "Test",
+            "test",
+            compositions: [new Composition { Key = compositionB.Key, CompositionType = CompositionType.Composition }]);
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.CompositionRemoved), "Expected CompositionRemoved flag");
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.CompositionAdded), "Expected CompositionAdded flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "CompositionRemoved should include RefreshMain");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshOther), "CompositionAdded should include RefreshOther");
+        });
+    }
+
+    [Test]
+    public async Task Add_Property_Emits_PropertyAdded()
+    {
+        var container = ContentTypePropertyContainerModel();
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Test", "test", containers: [container]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        var newPropertyType = ContentTypePropertyTypeModel("Title", "title", containerKey: container.Key);
+        var updateModel = ContentTypeUpdateModel("Test", "test", propertyTypes: [newPropertyType], containers: [container]);
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.PropertyAdded), "Expected PropertyAdded flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshOther), "PropertyAdded should include RefreshOther");
+            Assert.IsFalse(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.PropertyRemoved), "Did NOT expect PropertyRemoved flag");
+            Assert.IsFalse(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "Should NOT include RefreshMain");
+        });
+    }
+
+    [Test]
+    public async Task Add_Composition_Emits_CompositionAdded()
+    {
+        var compositionType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Composition", "composition",
+                propertyTypes: [ContentTypePropertyTypeModel("Comp Property", "compProperty")]),
+            Constants.Security.SuperUserKey)).Result!;
+
+        var contentType = (await ContentTypeEditingService.CreateAsync(
+            ContentTypeCreateModel("Test", "test"),
+            Constants.Security.SuperUserKey)).Result!;
+
+        ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads = null;
+        ContentTypeCacheRefreshedNotificationHandler.ContentTypeCacheRefreshed = payloads
+            => refreshedPayloads = payloads;
+
+        var updateModel = ContentTypeUpdateModel(
+            "Test",
+            "test",
+            compositions: [new Composition { Key = compositionType.Key, CompositionType = CompositionType.Composition }]);
+        var result = await ContentTypeEditingService.UpdateAsync(contentType, updateModel, Constants.Security.SuperUserKey);
+        Assert.IsTrue(result.Success);
+
+        Assert.IsNotNull(refreshedPayloads);
+        Assert.AreEqual(1, refreshedPayloads!.Length);
+        var payload = refreshedPayloads.First();
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.CompositionAdded), "Expected CompositionAdded flag");
+            Assert.IsTrue(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshOther), "CompositionAdded should include RefreshOther");
+            Assert.IsFalse(payload.ChangeTypes.HasTypesAll(ContentTypeChangeTypes.CompositionRemoved), "Did NOT expect CompositionRemoved flag");
+            Assert.IsFalse(payload.ChangeTypes.HasType(ContentTypeChangeTypes.RefreshMain), "Should NOT include RefreshMain");
+        });
+    }
+}
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentTypeEditingServiceTests.Update.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentTypeEditingServiceTests.Update.cs
index 05df46bfbd24..5c73bf461e03 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentTypeEditingServiceTests.Update.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/ContentTypeEditingServiceTests.Update.cs
@@ -72,8 +72,8 @@ public async Task Can_Update_Alias(bool isElement)
         Assert.AreEqual(isElement, contentType.IsElement);
         Assert.AreEqual("testUpdated", contentType.Alias);
 
-        // expect RefreshMain when changing alias
-        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshMain);
+        // expect AliasChanged (which includes RefreshMain) when changing alias
+        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.AliasChanged);
     }
 
     [TestCase(false, false)]
@@ -167,8 +167,8 @@ public async Task Can_Update_Property_Variation(bool variesByCulture, bool varie
 
         if (variesByCulture || variesBySegment)
         {
-            // expect RefreshMain when changing variation at property type level
-            AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshMain);
+            // expect PropertyVariationChanged (which includes RefreshMain) when changing variation at property type level
+            AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.PropertyVariationChanged);
         }
         else
         {
@@ -292,7 +292,7 @@ public async Task Can_Rearrange_Allowed_Types()
         Assert.IsTrue(allowedContentTypes.Any(c => c.Key == allowedOne.Key && c.SortOrder == 1 && c.Alias == allowedOne.Alias));
         Assert.IsTrue(allowedContentTypes.Any(c => c.Key == allowedTwo.Key && c.SortOrder == 0 && c.Alias == allowedTwo.Alias));
 
-        // expect RefreshOther when changing allowed types
+        // expect RefreshOther when only rearranging sort order (UnsortedSequenceEqual means AllowedContentTypes is not dirty)
         AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshOther);
     }
 
@@ -376,8 +376,8 @@ public async Task Can_Add_Properties(bool isElement)
 
         Assert.IsEmpty(contentType.NoGroupPropertyTypes);
 
-        // expect RefreshOther when adding properties
-        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshOther);
+        // expect PropertyAdded (which includes RefreshOther) when adding properties
+        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.PropertyAdded);
     }
 
     [TestCase(false)]
@@ -415,8 +415,8 @@ public async Task Can_Remove_Properties(bool isElement)
 
         Assert.AreEqual(0, contentType.NoGroupPropertyTypes.Count());
 
-        // expect RefreshMain when removing properties
-        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshMain);
+        // expect PropertyRemoved (which includes RefreshMain) when removing properties
+        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.PropertyRemoved);
     }
 
     [TestCase(false)]
@@ -463,8 +463,8 @@ public async Task Can_Remove_Single_Property_From_Container(bool isElement)
 
         Assert.AreEqual(0, contentType.NoGroupPropertyTypes.Count());
 
-        // expect RefreshMain when removing properties
-        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshMain);
+        // expect PropertyRemoved (which includes RefreshMain) when removing properties
+        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.PropertyRemoved);
     }
 
     [Test]
@@ -506,8 +506,8 @@ public async Task Can_Remove_Properties_Without_Container()
         Assert.AreEqual(0, contentType.PropertyTypes.Count());
         Assert.AreEqual(0, contentType.NoGroupPropertyTypes.Count());
 
-        // expect RefreshMain when removing properties
-        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshMain);
+        // expect PropertyRemoved (which includes RefreshMain) when removing properties
+        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.PropertyRemoved);
     }
 
     [TestCase(false)]
@@ -630,6 +630,7 @@ public async Task Can_Move_Properties_To_Another_Container(string containerType,
 
         var updateModel = ContentTypeUpdateModel(
             "Test Content Type",
+            isElement: isElement,
             containers: [container1, container2],
             propertyTypes: [propertyType1, propertyType2, propertyType3, propertyType4]);
         var updateAttempt = await ContentTypeEditingService.UpdateAsync(createAttempt.Result, updateModel, Constants.Security.SuperUserKey);
@@ -718,7 +719,7 @@ public async Task Can_Rearrange_Containers(bool isElement)
         Assert.AreEqual("testProperty2", sortedPropertyGroups.First().PropertyTypes!.Single().Alias);
         Assert.AreEqual("testProperty1", sortedPropertyGroups.Last().PropertyTypes!.Single().Alias);
 
-        // expect RefreshOther when changing moving properties (containers) around internally on the content type
+        // expect RefreshOther when only rearranging container sort order (PropertyGroups is not dirty for reordering)
         AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshOther);
     }
 
@@ -763,7 +764,7 @@ public async Task Can_Make_Properties_Orphaned(bool isElement)
         Assert.AreEqual("testProperty1", contentType.PropertyGroups.First().PropertyTypes!.Single().Alias);
         Assert.AreEqual("testProperty2", contentType.NoGroupPropertyTypes.Single().Alias);
 
-        // expect RefreshOther when changing moving properties (containers) around internally on the content type
+        // expect RefreshOther when modifying container structure
         AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshOther);
     }
 
@@ -807,8 +808,8 @@ public async Task Can_Add_Compositions()
         Assert.IsTrue(propertyTypeAliases.Contains("testProperty1"));
         Assert.IsTrue(propertyTypeAliases.Contains("testProperty2"));
 
-        // expect RefreshOther when adding compositions (corresponds to adding properties)
-        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshOther);
+        // expect CompositionAdded (which includes RefreshOther) when adding compositions
+        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.CompositionAdded);
     }
 
     [Test]
@@ -855,7 +856,7 @@ public async Task Can_Reapply_Compositions()
         Assert.IsTrue(propertyTypeAliases.Contains("testProperty1"));
         Assert.IsTrue(propertyTypeAliases.Contains("testProperty2"));
 
-        // expect RefreshOther when adding compositions (corresponds to adding properties)
+        // expect RefreshOther when re-applying the same compositions (in principle, nothing changes)
         AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshOther);
     }
 
@@ -897,8 +898,8 @@ public async Task Can_Remove_Compositions()
         Assert.AreEqual(1, contentType.CompositionPropertyTypes.Count());
         Assert.AreEqual("testProperty2", contentType.CompositionPropertyTypes.Single().Alias);
 
-        // expect RefreshMain when removing compositions (corresponds to removing properties)
-        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshMain);
+        // expect CompositionRemoved (which includes RefreshMain) when removing compositions
+        AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.CompositionRemoved);
     }
 
     [Test]
@@ -975,7 +976,7 @@ public async Task Can_Update_History_Cleanup()
         Assert.AreEqual(234, contentType.HistoryCleanup.KeepAllVersionsNewerThanDays);
         Assert.AreEqual(567, contentType.HistoryCleanup.KeepLatestVersionPerDayForDays);
 
-        // expect RefreshOther when changing basic settings
+        // expect RefreshOther when changing name.
         AssertContentTypeRefreshPayload(refreshedPayloads, contentType.Id, ContentTypeChangeTypes.RefreshOther);
     }
 
@@ -1027,7 +1028,7 @@ public async Task Can_Reapply_Compositions_For_Content_Type_With_Children()
             Assert.AreEqual(parentContentType.Key, childContentType.ContentTypeComposition.Single().Key);
         });
 
-        // expect RefreshOther when re-applying compositions (in principle, nothing changes)
+        // expect RefreshOther when re-applying compositions with a name change
         AssertContentTypeRefreshPayload(refreshedPayloads, parentContentType.Id, ContentTypeChangeTypes.RefreshOther);
     }
 
@@ -1075,11 +1076,10 @@ public async Task Can_Remove_Compositions_For_Content_Type_With_Children()
             Assert.AreEqual(parentContentType.Key, childContentType.ContentTypeComposition.Single().Key);
         });
 
-        // expect RefreshMain when removing compositions (corresponds to removing properties)
-        // - note that both parent and child content type are affected here
+        // expect CompositionRemoved for the parent and RefreshMain for the child (affected through composition propagation)
         Assert.IsNotNull(refreshedPayloads);
         Assert.AreEqual(2, refreshedPayloads.Length);
-        AssertContentTypeRefreshPayload([refreshedPayloads.First()], parentContentType.Id, ContentTypeChangeTypes.RefreshMain);
+        AssertContentTypeRefreshPayload([refreshedPayloads.First()], parentContentType.Id, ContentTypeChangeTypes.CompositionRemoved);
         AssertContentTypeRefreshPayload([refreshedPayloads.Last()], childContentType.Id, ContentTypeChangeTypes.RefreshMain);
     }
 
@@ -1512,8 +1512,9 @@ public async Task Can_Add_Composition_With_Conflicting_Property_Type_Alias_When_
             Assert.AreEqual("Same Test Property Alias", compositionProperty.Name);
         });
 
-        // expect RefreshMain, because a property was removed to "make room" for the new compositions
-        AssertContentTypeRefreshPayload(refreshedPayloads, targetContentType.Id, ContentTypeChangeTypes.RefreshMain);
+        // expect PropertyRemoved (which includes RefreshMain), because a property was removed to "make room" for the
+        // new composition - AND CompositionAdded, because the composition was also added in the same operation
+        AssertContentTypeRefreshPayload(refreshedPayloads, targetContentType.Id, ContentTypeChangeTypes.PropertyRemoved | ContentTypeChangeTypes.CompositionAdded);
     }
 
     private static void AssertContentTypeRefreshPayload(ContentTypeCacheRefresher.JsonPayload[]? refreshedPayloads, int expectedContentTypeId, ContentTypeChangeTypes expectedChangeTypes)
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlAliasServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlAliasServiceTests.cs
index c6b6a6351900..009c049cec61 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlAliasServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlAliasServiceTests.cs
@@ -885,7 +885,7 @@ public async Task InitAsync_Persists_Correct_Cache_Data()
         {
             Assert.That(singleAlias.DocumentKey, Is.EqualTo(singleAliasKey), "DocumentKey should match PageWithSingleAlias key");
             Assert.That(singleAlias.DocumentKey, Is.Not.EqualTo(Guid.Empty), "DocumentKey should not be empty GUID");
-            Assert.That(singleAlias.NullableLanguageId, Is.Null, "Invariant content should have NULL LanguageId");
+            Assert.That(singleAlias.LanguageId, Is.Null, "Invariant content should have NULL LanguageId");
             Assert.That(singleAlias.Alias, Is.EqualTo("my-single-alias"), "Alias should be normalized (lowercase, no leading slash)");
         });
 
@@ -907,7 +907,7 @@ public async Task InitAsync_Persists_Correct_Cache_Data()
             Assert.Multiple(() =>
             {
                 Assert.That(alias.DocumentKey, Is.Not.EqualTo(Guid.Empty), "DocumentKey should not be empty GUID");
-                Assert.That(alias.NullableLanguageId, Is.Null, "Invariant content should have NULL LanguageId");
+                Assert.That(alias.LanguageId, Is.Null, "Invariant content should have NULL LanguageId");
             });
         }
 
@@ -921,7 +921,7 @@ public async Task InitAsync_Persists_Correct_Cache_Data()
         {
             Assert.That(childAlias.DocumentKey, Is.EqualTo(childPageKey), "DocumentKey should match ChildPage key");
             Assert.That(childAlias.DocumentKey, Is.Not.EqualTo(Guid.Empty), "DocumentKey should not be empty GUID");
-            Assert.That(childAlias.NullableLanguageId, Is.Null, "Invariant content should have NULL LanguageId");
+            Assert.That(childAlias.LanguageId, Is.Null, "Invariant content should have NULL LanguageId");
             Assert.That(childAlias.Alias, Is.EqualTo("child-alias"), "Alias should be 'child-alias'");
         });
 
@@ -965,7 +965,7 @@ public async Task Invariant_Content_Stores_Null_LanguageId()
 
         // Assert - invariant content should have NULL languageId
         Assert.That(storedAliases, Has.Count.EqualTo(1));
-        Assert.That(storedAliases[0].NullableLanguageId, Is.Null, "Invariant content should have NULL LanguageId");
+        Assert.That(storedAliases[0].LanguageId, Is.Null, "Invariant content should have NULL LanguageId");
     }
 
     [Test]
@@ -998,7 +998,7 @@ public async Task Variant_Content_Stores_Specific_LanguageId()
         // Assert - variant content should have specific languageId (not NULL)
         var defaultLanguage = await LanguageService.GetDefaultLanguageAsync();
         Assert.That(storedAliases, Has.Count.EqualTo(1));
-        Assert.That(storedAliases[0].NullableLanguageId, Is.EqualTo(defaultLanguage.Id), "Variant content should have specific LanguageId");
+        Assert.That(storedAliases[0].LanguageId, Is.EqualTo(defaultLanguage.Id), "Variant content should have specific LanguageId");
     }
 
     [Test]
@@ -1020,7 +1020,7 @@ public async Task Changing_ContentType_From_Invariant_To_Variant_Updates_Alias_L
         }
 
         Assert.That(aliasesBefore, Has.Count.GreaterThan(0), "Should have aliases before change");
-        Assert.That(aliasesBefore.All(a => a.NullableLanguageId == null), Is.True, "All aliases should have NULL languageId before change");
+        Assert.That(aliasesBefore.All(a => a.LanguageId == null), Is.True, "All aliases should have NULL languageId before change");
 
         // Act - change content type from invariant to variant
         ContentType.Variations = ContentVariation.Culture;
@@ -1050,8 +1050,8 @@ public async Task Changing_ContentType_From_Invariant_To_Variant_Updates_Alias_L
         }
 
         Assert.That(aliasesAfter, Has.Count.GreaterThan(0), "Should have aliases after change");
-        Assert.That(aliasesAfter.All(a => a.NullableLanguageId != null), Is.True, "All aliases should have specific languageId after change to variant");
-        Assert.That(aliasesAfter.Any(a => a.NullableLanguageId == defaultLanguage.Id), Is.True, "Should have alias for default language");
+        Assert.That(aliasesAfter.All(a => a.LanguageId != null), Is.True, "All aliases should have specific languageId after change to variant");
+        Assert.That(aliasesAfter.Any(a => a.LanguageId == defaultLanguage.Id), Is.True, "Should have alias for default language");
     }
 
     [Test]
@@ -1073,7 +1073,7 @@ public async Task Changing_ContentType_From_Variant_To_Invariant_Updates_Alias_L
         }
 
         Assert.That(invariantAliases, Has.Count.GreaterThan(0), "Should have invariant aliases");
-        Assert.That(invariantAliases.All(a => a.NullableLanguageId == null), Is.True, "Invariant aliases should have NULL languageId");
+        Assert.That(invariantAliases.All(a => a.LanguageId == null), Is.True, "Invariant aliases should have NULL languageId");
 
         // Change content type to variant
         ContentType.Variations = ContentVariation.Culture;
@@ -1103,7 +1103,7 @@ public async Task Changing_ContentType_From_Variant_To_Invariant_Updates_Alias_L
         }
 
         Assert.That(variantAliases, Has.Count.GreaterThan(0), "Should have variant aliases after change to variant");
-        Assert.That(variantAliases.All(a => a.NullableLanguageId != null), Is.True, "All aliases should have specific languageId after change to variant");
+        Assert.That(variantAliases.All(a => a.LanguageId != null), Is.True, "All aliases should have specific languageId after change to variant");
 
         // Act - change content type from variant to invariant
         ContentType.Variations = ContentVariation.Nothing;
@@ -1129,7 +1129,7 @@ public async Task Changing_ContentType_From_Variant_To_Invariant_Updates_Alias_L
         }
 
         Assert.That(aliasesAfter, Has.Count.GreaterThan(0), "Should have aliases after change to invariant");
-        Assert.That(aliasesAfter.All(a => a.NullableLanguageId == null), Is.True, "All aliases should have NULL languageId after change to invariant");
+        Assert.That(aliasesAfter.All(a => a.LanguageId == null), Is.True, "All aliases should have NULL languageId after change to invariant");
     }
 
     #endregion
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlServiceTests.cs
index 253f7aed5221..8f19f46cbc1a 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlServiceTests.cs
@@ -97,10 +97,10 @@ public CustomUrlSegmentProvider2(IShortStringHelper stringHelper)
             => GetUrlSegment(content, culture, Guid.Parse(SubPage2Key), Guid.Parse(SubSubPage2Key));
     }
 
-    public override void Setup()
+    public override async Task Setup()
     {
         DocumentUrlService.InitAsync(false, CancellationToken.None).GetAwaiter().GetResult();
-        base.Setup();
+        await base.Setup();
     }
 
     //
@@ -605,7 +605,7 @@ public async Task Invariant_Content_Stores_Null_LanguageId_In_Database()
 
         foreach (var segment in storedSegments)
         {
-            Assert.That(segment.NullableLanguageId, Is.Null, "Invariant content should have NULL LanguageId in database");
+            Assert.That(segment.LanguageId, Is.Null, "Invariant content should have NULL LanguageId in database");
         }
     }
 
@@ -631,7 +631,7 @@ public async Task Changing_ContentType_From_Invariant_To_Variant_Updates_Url_Lan
         }
 
         Assert.That(segmentsBefore, Has.Count.GreaterThan(0), "Should have URL segments before change");
-        Assert.That(segmentsBefore.All(s => s.NullableLanguageId == null), Is.True, "All segments should have NULL languageId before change");
+        Assert.That(segmentsBefore.All(s => s.LanguageId == null), Is.True, "All segments should have NULL languageId before change");
 
         // Act - change content type from invariant to variant
         ContentType.Variations = ContentVariation.Culture;
@@ -655,8 +655,8 @@ public async Task Changing_ContentType_From_Invariant_To_Variant_Updates_Url_Lan
         }
 
         Assert.That(segmentsAfter, Has.Count.GreaterThan(0), "Should have URL segments after change");
-        Assert.That(segmentsAfter.All(s => s.NullableLanguageId != null), Is.True, "All segments should have specific languageId after change to variant");
-        Assert.That(segmentsAfter.Any(s => s.NullableLanguageId == defaultLanguage.Id), Is.True, "Should have segment for default language");
+        Assert.That(segmentsAfter.All(s => s.LanguageId != null), Is.True, "All segments should have specific languageId after change to variant");
+        Assert.That(segmentsAfter.Any(s => s.LanguageId == defaultLanguage.Id), Is.True, "Should have segment for default language");
     }
 
     [Test]
@@ -681,7 +681,7 @@ public async Task Changing_ContentType_From_Variant_To_Invariant_Updates_Url_Lan
         }
 
         Assert.That(invariantSegments, Has.Count.GreaterThan(0), "Should have invariant URL segments");
-        Assert.That(invariantSegments.All(s => s.NullableLanguageId == null), Is.True, "Invariant segments should have NULL languageId");
+        Assert.That(invariantSegments.All(s => s.LanguageId == null), Is.True, "Invariant segments should have NULL languageId");
 
         // Change content type to variant
         ContentType.Variations = ContentVariation.Culture;
@@ -705,7 +705,7 @@ public async Task Changing_ContentType_From_Variant_To_Invariant_Updates_Url_Lan
         }
 
         Assert.That(variantSegments, Has.Count.GreaterThan(0), "Should have variant URL segments after change to variant");
-        Assert.That(variantSegments.All(s => s.NullableLanguageId != null), Is.True, "All segments should have specific languageId after change to variant");
+        Assert.That(variantSegments.All(s => s.LanguageId != null), Is.True, "All segments should have specific languageId after change to variant");
 
         // Act - change content type from variant to invariant
         ContentType.Variations = ContentVariation.Nothing;
@@ -721,7 +721,7 @@ public async Task Changing_ContentType_From_Variant_To_Invariant_Updates_Url_Lan
         }
 
         Assert.That(segmentsAfter, Has.Count.GreaterThan(0), "Should have URL segments after change to invariant");
-        Assert.That(segmentsAfter.All(s => s.NullableLanguageId == null), Is.True, "All segments should have NULL languageId after change to invariant");
+        Assert.That(segmentsAfter.All(s => s.LanguageId == null), Is.True, "All segments should have NULL languageId after change to invariant");
     }
 
     #endregion
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlServiceTests_HideTopLevel_False.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlServiceTests_HideTopLevel_False.cs
index 75bd7f7017f6..b76284cae064 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlServiceTests_HideTopLevel_False.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/DocumentUrlServiceTests_HideTopLevel_False.cs
@@ -28,10 +28,10 @@ protected override void CustomTestSetup(IUmbracoBuilder builder)
         builder.AddNotificationHandler<ContentTreeChangeNotification, ContentTreeChangeDistributedCacheNotificationHandler>();
     }
 
-    public override void Setup()
+    public override async Task Setup()
     {
         DocumentUrlService.InitAsync(false, CancellationToken.None).GetAwaiter().GetResult();
-        base.Setup();
+        await base.Setup();
     }
 
     [Test]
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/MediaTypeEditingServiceTests.Update.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/MediaTypeEditingServiceTests.Update.cs
index 8bec94dfd470..9d1d87b13745 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/MediaTypeEditingServiceTests.Update.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/MediaTypeEditingServiceTests.Update.cs
@@ -129,7 +129,7 @@ public async Task Cannot_Change_Alias_Of_System_Media_Type(string mediaTypeAlias
         Assert.Multiple(() =>
         {
             Assert.IsFalse(result.Success);
-            Assert.AreEqual(ContentTypeOperationStatus.NotAllowed, result.Status);
+            Assert.AreEqual(ContentTypeOperationStatus.SystemAliasChangeNotAllowed, result.Status);
         });
     }
 }
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/PublishedUrlInfoProviderTestsBase.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/PublishedUrlInfoProviderTestsBase.cs
index dd65140891db..5ed87514f3f0 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/PublishedUrlInfoProviderTestsBase.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/PublishedUrlInfoProviderTestsBase.cs
@@ -33,10 +33,10 @@ protected override void CustomTestSetup(IUmbracoBuilder builder)
         builder.Services.AddUnique(CreateHttpContextAccessor());
     }
 
-    public override void Setup()
+    public override async Task Setup()
     {
         DocumentUrlService.InitAsync(false, CancellationToken.None).GetAwaiter().GetResult();
-        base.Setup();
+        await base.Setup();
     }
 
     private IUmbracoContext GetUmbracoContext(IServiceProvider serviceProvider)
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/TelemetryProviderTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/TelemetryProviderTests.cs
index 8cce10b7169a..8a2005387072 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/TelemetryProviderTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/TelemetryProviderTests.cs
@@ -25,8 +25,6 @@ internal sealed class TelemetryProviderTests : UmbracoIntegrationTest
 {
     private IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
 
-    private IFileService FileService => GetRequiredService<IFileService>();
-
     private IDomainService DomainService => GetRequiredService<IDomainService>();
 
     private IContentService ContentService => GetRequiredService<IContentService>();
@@ -56,6 +54,8 @@ internal sealed class TelemetryProviderTests : UmbracoIntegrationTest
 
     private IContentBlueprintEditingService ContentBlueprintEditingService => GetRequiredService<IContentBlueprintEditingService>();
 
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
+
     private readonly LanguageBuilder _languageBuilder = new();
 
     private readonly UserBuilder _userBuilder = new();
@@ -105,7 +105,7 @@ public async Task SectionService_Can_Get_Allowed_Sections_For_User()
     {
         // Arrange
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id);
         ContentTypeService.Save(contentType);
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/UserServiceCrudTests.Update.cs b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/UserServiceCrudTests.Update.cs
index d9a1fed95cb8..9deef8315e81 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/UserServiceCrudTests.Update.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Core/Services/UserServiceCrudTests.Update.cs
@@ -36,6 +36,7 @@ private async Task<UserUpdateModel> MapUserToUpdateModel(IUser user)
             LanguageIsoCode = user.Language,
             ContentStartNodeKeys = GetKeysFromIds(user.StartContentIds, UmbracoObjectTypes.Document),
             MediaStartNodeKeys = GetKeysFromIds(user.StartMediaIds, UmbracoObjectTypes.Media),
+            ElementStartNodeKeys = GetKeysFromIds(user.StartElementIds, UmbracoObjectTypes.ElementContainer),
             UserGroupKeys = groups.Select(x=>x.Key).ToHashSet(),
         };
     }
@@ -263,14 +264,19 @@ public async Task Can_Assign_User_Start_Nodes()
     {
         var contentService = GetRequiredService<IContentService>();
         var mediaService = GetRequiredService<IMediaService>();
+        var elementContainerService = GetRequiredService<IElementContainerService>();
         var contentStartNode = contentService.GetRootContent().First();
         var mediaStartNode = mediaService.CreateMediaWithIdentity("test", -1, "Image");
+        var elementContainerResult = await elementContainerService.CreateAsync(null, "TestElementFolder", null, Constants.Security.SuperUserKey);
+        Assert.IsTrue(elementContainerResult.Success);
+        var elementContainer = elementContainerResult.Result!;
 
         var userService = CreateUserService(securitySettings: new SecuritySettings { UsernameIsEmail = false });
 
         var (updateModel, createdUser) = await CreateUserForUpdate(userService);
         updateModel.ContentStartNodeKeys = new HashSet<Guid> { contentStartNode.Key };
         updateModel.MediaStartNodeKeys = new HashSet<Guid> { mediaStartNode.Key };
+        updateModel.ElementStartNodeKeys = new HashSet<Guid> { elementContainer.Key };
 
         var result = await userService.UpdateAsync(Constants.Security.SuperUserKey, updateModel);
 
@@ -284,19 +290,25 @@ public async Task Can_Assign_User_Start_Nodes()
         Assert.IsNotNull(updatedUser.StartMediaIds);
         Assert.AreEqual(1, updatedUser.StartMediaIds.Length);
         Assert.AreEqual(mediaStartNode.Id, updatedUser.StartMediaIds.First());
+        Assert.IsNotNull(updatedUser.StartElementIds);
+        Assert.AreEqual(1, updatedUser.StartElementIds.Length);
+        Assert.AreEqual(elementContainer.Id, updatedUser.StartElementIds.First());
     }
 
-    [TestCase(false, false)]
-    [TestCase(false, true)]
-    [TestCase(true, false)]
-    [TestCase(true, true)]
-    public async Task Can_Assign_Root_As_User_Start_Node(bool contentRootAccess, bool mediaRootAccess)
+    [TestCase(false, false, false)]
+    [TestCase(false, true, false)]
+    [TestCase(true, false, false)]
+    [TestCase(true, true, false)]
+    [TestCase(false, false, true)]
+    [TestCase(true, true, true)]
+    public async Task Can_Assign_Root_As_User_Start_Node(bool contentRootAccess, bool mediaRootAccess, bool elementRootAccess)
     {
         var userService = CreateUserService(securitySettings: new SecuritySettings { UsernameIsEmail = false });
 
         var (updateModel, createdUser) = await CreateUserForUpdate(userService);
         updateModel.HasContentRootAccess = contentRootAccess;
         updateModel.HasMediaRootAccess = mediaRootAccess;
+        updateModel.HasElementRootAccess = elementRootAccess;
 
         var result = await userService.UpdateAsync(Constants.Security.SuperUserKey, updateModel);
 
@@ -325,6 +337,17 @@ public async Task Can_Assign_Root_As_User_Start_Node(bool contentRootAccess, boo
         {
             Assert.IsEmpty(updatedUser.StartMediaIds);
         }
+
+        Assert.IsNotNull(updatedUser.StartElementIds);
+        if (elementRootAccess)
+        {
+            Assert.AreEqual(1, updatedUser.StartElementIds.Length);
+            Assert.AreEqual(Constants.System.Root, updatedUser.StartElementIds.First());
+        }
+        else
+        {
+            Assert.IsEmpty(updatedUser.StartElementIds);
+        }
     }
 
     // todo Ideally we would test content and media separately and together (Introduce Testcases for switching permutations)
@@ -333,14 +356,20 @@ public async Task Can_Unassign_User_Start_Nodes()
     {
         var contentService = GetRequiredService<IContentService>();
         var mediaService = GetRequiredService<IMediaService>();
+        var elementContainerService = GetRequiredService<IElementContainerService>();
         var contentStartNode = contentService.GetRootContent().First();
         var mediaStartNode = mediaService.CreateMediaWithIdentity("test", -1, "Image");
 
+        var elementContainerResult = await elementContainerService.CreateAsync(null, "TestElementFolder", null, Constants.Security.SuperUserKey);
+        Assert.IsTrue(elementContainerResult.Success);
+        var elementContainer = elementContainerResult.Result!;
+
         var userService = CreateUserService(securitySettings: new SecuritySettings { UsernameIsEmail = false });
 
         var (updateModel, createdUser) = await CreateUserForUpdate(userService);
         updateModel.ContentStartNodeKeys = new HashSet<Guid> { contentStartNode.Key };
         updateModel.MediaStartNodeKeys = new HashSet<Guid> { mediaStartNode.Key };
+        updateModel.ElementStartNodeKeys = new HashSet<Guid> { elementContainer.Key };
 
         await userService.UpdateAsync(Constants.Security.SuperUserKey, updateModel);
 
@@ -348,10 +377,12 @@ public async Task Can_Unassign_User_Start_Nodes()
         Assert.IsNotNull(updatedUser);
         Assert.IsNotEmpty(updatedUser.StartContentIds!);
         Assert.IsNotEmpty(updatedUser.StartMediaIds!);
+        Assert.IsNotEmpty(updatedUser.StartElementIds!);
 
         updateModel = await MapUserToUpdateModel(updatedUser);
         updateModel.ContentStartNodeKeys = new HashSet<Guid>();
         updateModel.MediaStartNodeKeys = new HashSet<Guid>();
+        updateModel.ElementStartNodeKeys = new HashSet<Guid>();
 
         var result = await userService.UpdateAsync(Constants.Security.SuperUserKey, updateModel);
 
@@ -364,6 +395,9 @@ public async Task Can_Unassign_User_Start_Nodes()
 
         Assert.IsNotNull(updatedUser.StartMediaIds);
         Assert.IsEmpty(updatedUser.StartMediaIds);
+
+        Assert.IsNotNull(updatedUser.StartElementIds);
+        Assert.IsEmpty(updatedUser.StartElementIds);
     }
 
     // todo Ideally we would test content and media separately and together (Introduce Testcases for switching permutations)
@@ -375,16 +409,19 @@ public async Task Can_Unassign_Root_As_User_Start_Node()
         var (updateModel, createdUser) = await CreateUserForUpdate(userService);
         updateModel.HasContentRootAccess = true;
         updateModel.HasMediaRootAccess = true;
+        updateModel.HasElementRootAccess = true;
 
         await userService.UpdateAsync(Constants.Security.SuperUserKey, updateModel);
         var updatedUser = await userService.GetAsync(createdUser.Key);
         Assert.IsNotNull(updatedUser);
         Assert.IsNotEmpty(updatedUser.StartContentIds!);
         Assert.IsNotEmpty(updatedUser.StartMediaIds!);
+        Assert.IsNotEmpty(updatedUser.StartElementIds!);
 
         updateModel = await MapUserToUpdateModel(updatedUser);
         updateModel.HasContentRootAccess = false;
         updateModel.HasMediaRootAccess = false;
+        updateModel.HasElementRootAccess = false;
 
         var result = await userService.UpdateAsync(Constants.Security.SuperUserKey, updateModel);
 
@@ -397,6 +434,9 @@ public async Task Can_Unassign_Root_As_User_Start_Node()
 
         Assert.IsNotNull(updatedUser.StartMediaIds);
         Assert.IsEmpty(updatedUser.StartMediaIds);
+
+        Assert.IsNotNull(updatedUser.StartElementIds);
+        Assert.IsEmpty(updatedUser.StartElementIds);
     }
 
     [TestCase(false, false)]
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Examine/DeliveryApiContentIndexHelperTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Examine/DeliveryApiContentIndexHelperTests.cs
index dc16d1ae16de..40eb3a2f082f 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Examine/DeliveryApiContentIndexHelperTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Examine/DeliveryApiContentIndexHelperTests.cs
@@ -1,6 +1,7 @@
 using Microsoft.Extensions.Options;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Services;
@@ -16,14 +17,14 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Examine;
 [TestFixture]
 public class DeliveryApiContentIndexHelperTests : UmbracoIntegrationTestWithContent
 {
-    public override void CreateTestData()
+    public override async Task CreateTestDataAsync()
     {
-        base.CreateTestData();
+        await base.CreateTestDataAsync();
 
         // Save an extra, published content item of a different type to those created via the base class,
         // that we'll use to test filtering out disallowed content types.
         var template = TemplateBuilder.CreateTextPageTemplate("textPage2");
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType("umbTextpage2", "Textpage2", defaultTemplateId: template.Id);
         contentType.Key = Guid.NewGuid();
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Packaging/PackageDataInstallationTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Packaging/PackageDataInstallationTests.cs
index 5b62f36f4233..3229f978ddcf 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Packaging/PackageDataInstallationTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Packaging/PackageDataInstallationTests.cs
@@ -1,8 +1,6 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using System.Collections.Generic;
-using System.Linq;
 using System.Xml.Linq;
 using NUnit.Framework;
 using Umbraco.Cms.Core;
@@ -11,7 +9,6 @@
 using Umbraco.Cms.Core.Models.Packaging;
 using Umbraco.Cms.Core.PropertyEditors;
 using Umbraco.Cms.Core.Services;
-using Umbraco.Cms.Infrastructure.Packaging;
 using Umbraco.Cms.Infrastructure.Persistence.Dtos;
 using Umbraco.Cms.Tests.Common.Attributes;
 using Umbraco.Cms.Tests.Common.Testing;
@@ -25,6 +22,7 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Packaging;
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest, WithApplication = true)]
 internal sealed class PackageDataInstallationTests : UmbracoIntegrationTestWithContent
 {
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
     private ILanguageService LanguageService => GetRequiredService<ILanguageService>();
 
     private IDictionaryItemService DictionaryItemService => GetRequiredService<IDictionaryItemService>();
@@ -79,10 +77,10 @@ public Editor2(IDataValueEditorFactory dataValueEditorFactory)
 
     private IMediaTypeService MediaTypeService => GetRequiredService<IMediaTypeService>();
 
-    public override void CreateTestData()
+    public override async Task CreateTestDataAsync()
     {
         DeleteAllTemplateViewFiles();
-        base.CreateTestData();
+        await base.CreateTestDataAsync();
     }
 
     [Test]
@@ -209,12 +207,12 @@ public async Task Can_Import_Template_Package_Xml()
         var xml = XElement.Parse(strXml);
         var element = xml.Descendants("Templates").First();
 
-        var init = FileService.GetTemplates().Count();
+        var init = (await TemplateService.GetAllAsync()).Count();
 
         // Act
         var templates = await PackageDataInstallation.ImportTemplatesAsync(element.Elements("Template").ToList(), -1);
         var numberOfTemplates = (from doc in element.Elements("Template") select doc).Count();
-        var allTemplates = FileService.GetTemplates();
+        var allTemplates = await TemplateService.GetAllAsync();
 
         // Assert
         Assert.That(templates, Is.Not.Null);
@@ -552,17 +550,15 @@ public async Task Can_ReImport_Templates_To_Update()
         var templateElement = newPackageXml.Descendants("Templates").First();
         var templateElementUpdated = updatedPackageXml.Descendants("Templates").First();
 
-        var fileService = FileService;
-
         // kill default test data
-        fileService.DeleteTemplate("defaultTemplate");
+        await TemplateService.DeleteAsync("defaultTemplate", Constants.Security.SuperUserKey);
 
         // Act
         var numberOfTemplates = (from doc in templateElement.Elements("Template") select doc).Count();
         var templates = await PackageDataInstallation.ImportTemplatesAsync(templateElement.Elements("Template").ToList(), -1);
         var templatesAfterUpdate =
             await PackageDataInstallation.ImportTemplatesAsync(templateElementUpdated.Elements("Template").ToList(), -1);
-        var allTemplates = fileService.GetTemplates();
+        var allTemplates = await TemplateService.GetAllAsync();
 
         // Assert
         Assert.That(templates.Any(), Is.True);
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/ContentTypeRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/ContentTypeRepositoryTest.cs
index 9c1521d0ed45..89d6d882e20f 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/ContentTypeRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/ContentTypeRepositoryTest.cs
@@ -1169,4 +1169,108 @@ DocumentPropertyValueGranularPermission CreatePermission(IPropertyType propertyT
         Assert.AreEqual(4, userGroup.GranularPermissions.Count);
         return userGroup;
     }
+
+    [Test]
+    public void Get_By_Guid_Returns_Deep_Clone_Not_Cached_Instance()
+    {
+        var provider = ScopeProvider;
+        using (var scope = provider.CreateScope())
+        {
+            var repository = ContentTypeRepository;
+
+            var first = repository.Get(_simpleContentType.Key);
+            var second = repository.Get(_simpleContentType.Key);
+
+            Assert.IsNotNull(first);
+            Assert.IsNotNull(second);
+            Assert.AreEqual(first.Id, second.Id);
+
+            // Must be different object references (deep clones, not the cached original).
+            Assert.AreNotSame(first, second);
+        }
+    }
+
+    [Test]
+    public void Get_By_Alias_Returns_Correct_ContentType()
+    {
+        var provider = ScopeProvider;
+        using (var scope = provider.CreateScope())
+        {
+            var repository = ContentTypeRepository;
+
+            // Case-insensitive alias lookup.
+            var result = repository.Get("UMBTEXTPAGE");
+
+            Assert.IsNotNull(result);
+            Assert.AreEqual(_simpleContentType.Id, result!.Id);
+            Assert.AreEqual("umbTextpage", result.Alias);
+        }
+    }
+
+    [Test]
+    public void Get_By_Alias_Returns_Deep_Clone_Not_Cached_Instance()
+    {
+        var provider = ScopeProvider;
+        using (var scope = provider.CreateScope())
+        {
+            var repository = ContentTypeRepository;
+
+            var first = repository.Get("umbTextpage");
+            var second = repository.Get("umbTextpage");
+
+            Assert.IsNotNull(first);
+            Assert.IsNotNull(second);
+            Assert.AreEqual(first!.Id, second!.Id);
+            Assert.AreNotSame(first, second);
+        }
+    }
+
+    [Test]
+    public void Exists_By_Guid_Returns_True_For_Existing_Type()
+    {
+        var provider = ScopeProvider;
+        using (var scope = provider.CreateScope())
+        {
+            var repository = ContentTypeRepository;
+
+            var exists = repository.Exists(_simpleContentType.Key);
+
+            Assert.IsTrue(exists);
+        }
+    }
+
+    [Test]
+    public void Exists_By_Guid_Returns_False_For_NonExisting_Type()
+    {
+        var provider = ScopeProvider;
+        using (var scope = provider.CreateScope())
+        {
+            var repository = ContentTypeRepository;
+
+            var exists = repository.Exists(Guid.NewGuid());
+
+            Assert.IsFalse(exists);
+        }
+    }
+
+    [Test]
+    public void Get_By_Guid_Mutation_Does_Not_Affect_Subsequent_Get()
+    {
+        var provider = ScopeProvider;
+        using (var scope = provider.CreateScope())
+        {
+            var repository = ContentTypeRepository;
+
+            // Get a content type and mutate its name.
+            var first = repository.Get(_simpleContentType.Key);
+            Assert.IsNotNull(first);
+            var originalName = first!.Name;
+            first.Name = "MUTATED_NAME_" + Guid.NewGuid();
+
+            // A subsequent Get should return an unmodified clone.
+            var second = repository.Get(_simpleContentType.Key);
+            Assert.IsNotNull(second);
+            Assert.AreEqual(originalName, second!.Name, "Mutation of a returned entity should not affect the cached copy");
+        }
+    }
 }
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentRepositoryTest.cs
index cb310e83f318..0181ac15b5dc 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentRepositoryTest.cs
@@ -38,9 +38,9 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Persistence.Repos
 internal sealed class DocumentRepositoryTest : UmbracoIntegrationTest
 {
     [SetUp]
-    public void SetUpData()
+    public async Task SetUpData()
     {
-        CreateTestData();
+        await CreateTestData();
 
         ContentRepositoryBase.ThrowOnWarning = true;
     }
@@ -58,10 +58,10 @@ public void SetUpData()
 
     private IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
 
-    private IFileService FileService => GetRequiredService<IFileService>();
-
     private IDataTypeService DataTypeService => GetRequiredService<IDataTypeService>();
 
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
+
     private FileSystems FileSystems => GetRequiredService<FileSystems>();
 
     private PropertyEditorCollection PropertyEditorCollection => GetRequiredService<PropertyEditorCollection>();
@@ -69,10 +69,10 @@ public void SetUpData()
     private IConfigurationEditorJsonSerializer ConfigurationEditorJsonSerializer =>
         GetRequiredService<IConfigurationEditorJsonSerializer>();
 
-    public void CreateTestData()
+    public async Task CreateTestData()
     {
         var template = TemplateBuilder.CreateTextPageTemplate("defaultTemplate");
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         // Create and Save ContentType "umbTextpage" -> (_contentType.Id)
         _contentType =
@@ -167,7 +167,7 @@ private DocumentRepository CreateRepository(IScopeAccessor scopeAccessor, out Co
     }
 
     [Test]
-    public void Retrievals_By_Id_And_Key_After_Save_Are_Cached()
+    public async Task Retrievals_By_Id_And_Key_After_Save_Are_Cached()
     {
         var realCache = new AppCaches(
             new ObjectCacheAppCache(),
@@ -184,7 +184,7 @@ public void Retrievals_By_Id_And_Key_After_Save_Are_Cached()
 
         database.EnableSqlCount = false;
 
-        var content = CreateContent(repository, contentTypeRepository);
+        var content = await CreateContent(repository, contentTypeRepository);
 
         database.EnableSqlCount = true;
 
@@ -203,7 +203,7 @@ public void Retrievals_By_Id_And_Key_After_Save_Are_Cached()
     }
 
     [Test]
-    public void Retrieval_By_Key_After_Retrieval_By_Id_Is_Cached()
+    public async Task Retrieval_By_Key_After_Retrieval_By_Id_Is_Cached()
     {
         var realCache = new AppCaches(
             new ObjectCacheAppCache(),
@@ -220,7 +220,7 @@ public void Retrieval_By_Key_After_Retrieval_By_Id_Is_Cached()
 
         database.EnableSqlCount = false;
 
-        var content = CreateContent(repository, contentTypeRepository);
+        var content = await CreateContent(repository, contentTypeRepository);
 
         database.EnableSqlCount = true;
 
@@ -244,7 +244,7 @@ public void Retrieval_By_Key_After_Retrieval_By_Id_Is_Cached()
     }
 
     [Test]
-    public void Retrieval_By_Id_After_Retrieval_By_Key_Is_Cached()
+    public async Task Retrieval_By_Id_After_Retrieval_By_Key_Is_Cached()
     {
         var realCache = new AppCaches(
             new ObjectCacheAppCache(),
@@ -261,7 +261,7 @@ public void Retrieval_By_Id_After_Retrieval_By_Key_Is_Cached()
 
         database.EnableSqlCount = false;
 
-        var content = CreateContent(repository, contentTypeRepository);
+        var content = await CreateContent(repository, contentTypeRepository);
 
         database.EnableSqlCount = true;
 
@@ -284,10 +284,10 @@ public void Retrieval_By_Id_After_Retrieval_By_Key_Is_Cached()
         Assert.AreEqual(0, database.SqlCount);
     }
 
-    private Content CreateContent(DocumentRepository repository, ContentTypeRepository contentTypeRepository)
+    private async Task<Content> CreateContent(DocumentRepository repository, ContentTypeRepository contentTypeRepository)
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbTextpage1", "Textpage", defaultTemplateId: template.Id);
 
@@ -298,7 +298,7 @@ private Content CreateContent(DocumentRepository repository, ContentTypeReposito
     }
 
     [Test]
-    public void CreateVersions()
+    public async Task CreateVersions()
     {
         var provider = ScopeProvider;
         using (var scope = provider.CreateScope())
@@ -306,7 +306,7 @@ public void CreateVersions()
             var repository = CreateRepository((IScopeAccessor)provider, out var contentTypeRepository, out DataTypeRepository _);
             var versions = new List<int>();
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
             var hasPropertiesContentType =
                 ContentTypeBuilder.CreateSimpleContentType("umbTextpage1", "Textpage", defaultTemplateId: template.Id);
 
@@ -505,13 +505,13 @@ public void CreateVersions()
     ///     To test, we have 3 content items, the first has properties, the second doesn't and the third does.
     /// </remarks>
     [Test]
-    public void PropertyDataAssignedCorrectly()
+    public async Task PropertyDataAssignedCorrectly()
     {
         var provider = ScopeProvider;
         using (var scope = provider.CreateScope())
         {
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var repository = CreateRepository((IScopeAccessor)provider, out var contentTypeRepository, out DataTypeRepository _);
 
@@ -605,13 +605,13 @@ public void PropertyDataAssignedCorrectly()
     //// }
 
     [Test]
-    public void SaveContent()
+    public async Task SaveContent()
     {
         var provider = ScopeProvider;
         using (var scope = provider.CreateScope())
         {
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
             var repository = CreateRepository((IScopeAccessor)provider, out var contentTypeRepository);
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("umbTextpage2", "Textpage", defaultTemplateId: template.Id);
@@ -661,14 +661,14 @@ public void SaveContentWithDefaultTemplate()
 
     // Covers issue U4-2791 and U4-2607
     [Test]
-    public void SaveContentWithAtSignInName()
+    public async Task SaveContentWithAtSignInName()
     {
         // Arrange
         var provider = ScopeProvider;
         using (var scope = provider.CreateScope())
         {
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
             var repository = CreateRepository((IScopeAccessor)provider, out var contentTypeRepository);
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("umbTextpage1", "Textpage", defaultTemplateId: template.Id);
@@ -694,13 +694,13 @@ public void SaveContentWithAtSignInName()
     }
 
     [Test]
-    public void SaveContentMultiple()
+    public async Task SaveContentMultiple()
     {
         var provider = ScopeProvider;
         using (var scope = provider.CreateScope())
         {
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
             var repository = CreateRepository((IScopeAccessor)provider, out var contentTypeRepository);
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("umbTextpage1", "Textpage", defaultTemplateId: template.Id);
@@ -893,13 +893,13 @@ public void AliasRegexTest()
     }
 
     [Test]
-    public void GetPagedResultsByQuery_With_Variant_Names()
+    public async Task GetPagedResultsByQuery_With_Variant_Names()
     {
         using var efCoreScope = NewScopeProvider.CreateScope();
 
         // One invariant content type named "umbInvariantTextPage"
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var invariantCt = ContentTypeBuilder.CreateSimpleContentType("umbInvariantTextpage", "Invariant Textpage", defaultTemplateId: template.Id);
         invariantCt.Variations = ContentVariation.Nothing;
         foreach (var p in invariantCt.PropertyTypes)
@@ -1253,7 +1253,7 @@ public void QueryContentByUniqueId()
     /// the fix is applied.
     /// </remarks>
     [Test]
-    public void GetMany_By_Guid_With_Warm_Cache_Returns_All()
+    public async Task GetMany_By_Guid_With_Warm_Cache_Returns_All()
     {
         var realCache = new AppCaches(
             new ObjectCacheAppCache(),
@@ -1265,7 +1265,7 @@ public void GetMany_By_Guid_With_Warm_Cache_Returns_All()
         using var scope = provider.CreateScope();
         var repository = CreateRepository((IScopeAccessor)provider, out var contentTypeRepository, realCache);
 
-        var content = CreateContent(repository, contentTypeRepository);
+        var content = await CreateContent(repository, contentTypeRepository);
 
         var guidRepo = (IReadRepository<Guid, IContent>)repository;
 
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentVersionRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentVersionRepositoryTest.cs
index eef13b463a5b..82182b356645 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentVersionRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DocumentVersionRepositoryTest.cs
@@ -9,44 +9,42 @@
 using Umbraco.Cms.Tests.Common.Builders;
 using Umbraco.Cms.Tests.Common.Testing;
 using Umbraco.Cms.Tests.Integration.Testing;
-using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Persistence.Repositories;
 
-/// <remarks>
-///     v9 -> Tests.Integration
-/// </remarks>
 [TestFixture]
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
 internal sealed class DocumentVersionRepositoryTest : UmbracoIntegrationTest
 {
-    public IFileService FileService => GetRequiredService<IFileService>();
+    public ITemplateService TemplateService => GetRequiredService<ITemplateService>();
+
     public IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
+
     public IContentService ContentService => GetRequiredService<IContentService>();
 
     [Test]
-    public void GetDocumentVersionsEligibleForCleanup_Always_ExcludesActiveVersions()
+    public async Task GetContentVersionsEligibleForCleanup_Always_ExcludesActiveVersions()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Cms.Core.Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
-        ContentTypeService.Save(contentType);
+        await ContentTypeService.CreateAsync(contentType, Cms.Core.Constants.Security.SuperUserKey);
 
         var content = ContentBuilder.CreateSimpleContent(contentType);
         ContentService.Save(content);
 
-        ContentService.Publish(content, Array.Empty<string>());
+        ContentService.Publish(content, []);
         // At this point content has 2 versions, a draft version and a published version.
 
-        ContentService.Publish(content, Array.Empty<string>());
+        ContentService.Publish(content, []);
         // At this point content has 3 versions, a historic version, a draft version and a published version.
 
         using (ScopeProvider.CreateScope())
         {
             var sut = new DocumentVersionRepository(ScopeAccessor);
-            var results = sut.GetContentVersionsEligibleForCleanup();
+            var results = sut.GetContentVersionsEligibleForCleanup(DateTime.UtcNow.AddDays(1), null);
 
             Assert.Multiple(() =>
             {
@@ -57,24 +55,24 @@ public void GetDocumentVersionsEligibleForCleanup_Always_ExcludesActiveVersions(
     }
 
     [Test]
-    public void GetDocumentVersionsEligibleForCleanup_Always_ExcludesPinnedVersions()
+    public async Task GetContentVersionsEligibleForCleanup_Always_ExcludesPinnedVersions()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Cms.Core.Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
-        ContentTypeService.Save(contentType);
-        ContentTypeService.Save(contentType);
+        await ContentTypeService.CreateAsync(contentType, Cms.Core.Constants.Security.SuperUserKey);
 
         var content = ContentBuilder.CreateSimpleContent(contentType);
         ContentService.Save(content);
 
-        ContentService.Publish(content, Array.Empty<string>());
+        ContentService.Publish(content, []);
         // At this point content has 2 versions, a draft version and a published version.
-        ContentService.Publish(content, Array.Empty<string>());
-        ContentService.Publish(content, Array.Empty<string>());
-        ContentService.Publish(content, Array.Empty<string>());
+
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
         // At this point content has 5 versions, 3 historic versions, a draft version and a published version.
 
         var allVersions = ContentService.GetVersions(content.Id);
@@ -85,7 +83,7 @@ public void GetDocumentVersionsEligibleForCleanup_Always_ExcludesPinnedVersions(
             ScopeAccessor.AmbientScope.Database.Update<ContentVersionDto>("set preventCleanup = 1 where id in (1,3)");
 
             var sut = new DocumentVersionRepository(ScopeAccessor);
-            var results = sut.GetContentVersionsEligibleForCleanup();
+            var results = sut.GetContentVersionsEligibleForCleanup(DateTime.UtcNow.AddDays(1), null);
 
             Assert.Multiple(() =>
             {
@@ -101,22 +99,106 @@ public void GetDocumentVersionsEligibleForCleanup_Always_ExcludesPinnedVersions(
     }
 
     [Test]
-    public void DeleteVersions_Always_DeletesSpecifiedVersions()
+    public async Task GetContentVersionsEligibleForCleanup_WithDateFilter_OnlyReturnsOlderVersions()
+    {
+        var template = TemplateBuilder.CreateTextPageTemplate();
+        await TemplateService.CreateAsync(template, Cms.Core.Constants.Security.SuperUserKey);
+
+        var contentType =
+            ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
+        await ContentTypeService.CreateAsync(contentType, Cms.Core.Constants.Security.SuperUserKey);
+
+        // Create 4 versions in total: 2 historic (1, 2), 1 current draft (3), 1 current published (4).
+        var content = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content);
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
+
+        using (ScopeProvider.CreateScope())
+        {
+            var db = ScopeAccessor.AmbientScope!.Database;
+            var syntax = ScopeAccessor.AmbientScope.SqlContext.SqlSyntax;
+
+            // Backdate version 1 to 10 days ago, leave version 2 at today.
+            db.Execute(
+                $"UPDATE {syntax.GetQuotedTableName("umbracoContentVersion")} SET {syntax.GetQuotedColumnName("versionDate")} = @0 WHERE {syntax.GetQuotedColumnName("id")} = 1",
+                DateTime.UtcNow.AddDays(-10));
+
+            var sut = new DocumentVersionRepository(ScopeAccessor);
+
+            // Cutoff at 5 days ago — should only return version 1.
+            var results = sut.GetContentVersionsEligibleForCleanup(DateTime.UtcNow.AddDays(-5), null);
+
+            Assert.Multiple(() =>
+            {
+                Assert.AreEqual(1, results.Count);
+                Assert.AreEqual(1, results.First().VersionId);
+            });
+        }
+    }
+
+    [Test]
+    public async Task GetContentVersionsEligibleForCleanup_WithMaxCount_RespectsLimitAndReturnsOldestFirst()
+    {
+        var template = TemplateBuilder.CreateTextPageTemplate();
+        await TemplateService.CreateAsync(template, Cms.Core.Constants.Security.SuperUserKey);
+
+        var contentType =
+            ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
+        await ContentTypeService.CreateAsync(contentType, Cms.Core.Constants.Security.SuperUserKey);
+
+        // Create 5 versions in total: 3 historic (1, 2, 3), 1 current draft (4), 1 current published (5).
+        var content = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content);
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
+
+        using (ScopeProvider.CreateScope())
+        {
+            var db = ScopeAccessor.AmbientScope!.Database;
+            var syntax = ScopeAccessor.AmbientScope.SqlContext.SqlSyntax;
+
+            // Backdate all historic versions so they pass the date filter.
+            db.Execute(
+                $"UPDATE {syntax.GetQuotedTableName("umbracoContentVersion")} SET {syntax.GetQuotedColumnName("versionDate")} = @0 WHERE {syntax.GetQuotedColumnName("id")} IN (1, 2, 3)",
+                DateTime.UtcNow.AddDays(-10));
+
+            var sut = new DocumentVersionRepository(ScopeAccessor);
+
+            // Request at most 2 — should return the 2 oldest of the 3 eligible.
+            var results = sut.GetContentVersionsEligibleForCleanup(DateTime.UtcNow, 2);
+
+            Assert.Multiple(() =>
+            {
+                Assert.AreEqual(2, results.Count);
+
+                // Should be ordered oldest first (by versionDate ASC, and since all have same date, by id ASC).
+                var ids = results.Select(x => x.VersionId).ToList();
+                Assert.That(ids, Is.Ordered.Ascending);
+            });
+        }
+    }
+
+    [Test]
+    public async Task DeleteVersions_Always_DeletesSpecifiedVersions()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Cms.Core.Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
-        ContentTypeService.Save(contentType);
+        await ContentTypeService.CreateAsync(contentType, Cms.Core.Constants.Security.SuperUserKey);
 
         var content = ContentBuilder.CreateSimpleContent(contentType);
         ContentService.Save(content);
 
-        ContentService.Publish(content, Array.Empty<string>());
-        ContentService.Publish(content, Array.Empty<string>());
-        ContentService.Publish(content, Array.Empty<string>());
-        ContentService.Publish(content, Array.Empty<string>());
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
         using (var scope = ScopeProvider.CreateScope())
         {
             var query = ScopeAccessor.AmbientScope.SqlContext.Sql();
@@ -137,22 +219,77 @@ public void DeleteVersions_Always_DeletesSpecifiedVersions()
         }
     }
 
+    [Test]
+    public async Task DeleteVersions_VerifiesCascadeDeletion()
+    {
+        var template = TemplateBuilder.CreateTextPageTemplate();
+        await TemplateService.CreateAsync(template, Cms.Core.Constants.Security.SuperUserKey);
+
+        var contentType =
+            ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
+        await ContentTypeService.CreateAsync(contentType, Cms.Core.Constants.Security.SuperUserKey);
+
+        var content = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content);
+
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
+        ContentService.Publish(content, []);
+
+        // At this point content has 4 versions: 2 historic, 1 draft, 1 published.
+        using (var scope = ScopeProvider.CreateScope())
+        {
+            var db = ScopeAccessor.AmbientScope!.Database;
+            var syntax = ScopeAccessor.AmbientScope.SqlContext.SqlSyntax;
+
+            // Verify initial state has rows in all relevant tables
+            var beforeContentVersions = db.Single<int>($"SELECT count(1) FROM {syntax.GetQuotedTableName("umbracoContentVersion")}");
+            var beforeDocumentVersions = db.Single<int>($"SELECT count(1) FROM {syntax.GetQuotedTableName("umbracoDocumentVersion")}");
+            var beforePropertyData = db.Single<int>($"SELECT count(1) FROM {syntax.GetQuotedTableName("umbracoPropertyData")}");
+
+            Assert.Greater(beforeContentVersions, 2, "Should have more than 2 content versions before delete");
+            Assert.Greater(beforeDocumentVersions, 2, "Should have more than 2 document versions before delete");
+            Assert.Greater(beforePropertyData, 6, "Should have more than 6 property data rows before delete");
+
+            var sut = new DocumentVersionRepository(ScopeAccessor);
+            // Delete the 2 historic versions (IDs 1 and 2)
+            sut.DeleteVersions(new[] { 1, 2 });
+
+            var afterContentVersions = db.Single<int>($"SELECT count(1) FROM {syntax.GetQuotedTableName("umbracoContentVersion")}");
+            var afterDocumentVersions = db.Single<int>($"SELECT count(1) FROM {syntax.GetQuotedTableName("umbracoDocumentVersion")}");
+            var afterPropertyData = db.Single<int>($"SELECT count(1) FROM {syntax.GetQuotedTableName("umbracoPropertyData")}");
+            var afterCultureVariation = db.Single<int>($"SELECT count(1) FROM {syntax.GetQuotedTableName("umbracoContentVersionCultureVariation")} WHERE {syntax.GetQuotedColumnName("versionId")} IN (1, 2)");
+
+            Assert.Multiple(() =>
+            {
+                // 2 versions deleted, 2 remain (current draft + current published)
+                Assert.AreEqual(beforeContentVersions - 2, afterContentVersions);
+                Assert.AreEqual(beforeDocumentVersions - 2, afterDocumentVersions);
+
+                // CreateSimpleContentType has 3 properties, so 6 property data rows should be removed
+                Assert.AreEqual(beforePropertyData - 6, afterPropertyData);
+
+                // No culture variation rows for the deleted versions
+                Assert.AreEqual(0, afterCultureVariation);
+            });
+        }
+    }
 
     [Test]
-    public void GetPagedItemsByContentId_WithInvariantCultureContent_ReturnsPaginatedResults()
+    public async Task GetPagedItemsByContentId_WithInvariantCultureContent_ReturnsPaginatedResults()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Cms.Core.Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
-        ContentTypeService.Save(contentType);
+        await ContentTypeService.CreateAsync(contentType, Cms.Core.Constants.Security.SuperUserKey);
 
         var content = ContentBuilder.CreateSimpleContent(contentType);
         ContentService.Save(content);
 
-        ContentService.Publish(content, Array.Empty<string>()); // Draft + Published
-        ContentService.Publish(content, Array.Empty<string>()); // New Draft
+        ContentService.Publish(content, []); // Draft + Published
+        ContentService.Publish(content, []); // New Draft
 
         using (ScopeProvider.CreateScope())
         {
@@ -172,10 +309,10 @@ public void GetPagedItemsByContentId_WithInvariantCultureContent_ReturnsPaginate
     }
 
     [Test]
-    public void GetPagedItemsByContentId_WithVariantCultureContent_ReturnsPaginatedResults()
+    public async Task GetPagedItemsByContentId_WithVariantCultureContent_ReturnsPaginatedResults()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Cms.Core.Constants.Security.SuperUserKey);
 
         var contentType =
             ContentTypeBuilder.CreateSimpleContentType("umbTextpage", "Textpage", defaultTemplateId: template.Id);
@@ -185,15 +322,14 @@ public void GetPagedItemsByContentId_WithVariantCultureContent_ReturnsPaginatedR
             propertyType.Variations = ContentVariation.Culture;
         }
 
-        FileService.SaveTemplate(contentType.DefaultTemplate);
-        ContentTypeService.Save(contentType);
+        await ContentTypeService.UpdateAsync(contentType, Cms.Core.Constants.Security.SuperUserKey);
 
         var content = ContentBuilder.CreateSimpleContent(contentType, "foo", culture: "en-US");
         content.SetCultureName("foo", "en-US");
 
         ContentService.Save(content);
-        ContentService.Publish(content, new[] { "en-US" }); // Draft + Published
-        ContentService.Publish(content, new[] { "en-US" }); // New Draft
+        ContentService.Publish(content, ["en-US"]); // Draft + Published
+        ContentService.Publish(content, ["en-US"]); // New Draft
 
         using (ScopeProvider.CreateScope())
         {
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DomainRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DomainRepositoryTest.cs
index d3740f57b731..ef1f708cad0c 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DomainRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/DomainRepositoryTest.cs
@@ -1,18 +1,10 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using System.Collections.Generic;
 using System.Data;
-using System.Linq;
-using Microsoft.Extensions.Logging;
-using Moq;
 using NUnit.Framework;
-using Umbraco.Cms.Core.Cache;
-using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Persistence.Repositories;
-using Umbraco.Cms.Infrastructure.Persistence.Repositories.Implement;
-using Umbraco.Cms.Infrastructure.Scoping;
 using Umbraco.Cms.Tests.Common.Builders;
 using Umbraco.Cms.Tests.Common.Testing;
 using Umbraco.Cms.Tests.Integration.Testing;
@@ -29,338 +21,289 @@ internal sealed class DomainRepositoryTest : UmbracoIntegrationTest
 
     private IContentTypeRepository ContentTypeRepository => GetRequiredService<IContentTypeRepository>();
 
-    private DomainRepository CreateRepository(IScopeProvider provider)
-    {
-        var accessor = (IScopeAccessor)provider;
-        var domainRepository =
-            new DomainRepository(accessor, AppCaches.NoCache, LoggerFactory.CreateLogger<DomainRepository>(), Mock.Of<IRepositoryCacheVersionService>(), Mock.Of<ICacheSyncService>());
-        return domainRepository;
-    }
+    private IDomainRepository DomainRepository => GetRequiredService<IDomainRepository>();
 
-    private int CreateTestData(string isoName, out ContentType ct)
+    private async Task<(IContent Content, ContentType ContentType)> CreateTestDataAsync(string isoName)
     {
         var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
         using (var scope = provider.CreateScope())
         {
             var lang = new Language(isoName, isoName);
-            LanguageRepository.SaveAsync(lang, CancellationToken.None).GetAwaiter().GetResult();
+            await LanguageRepository.SaveAsync(lang, CancellationToken.None);
 
-            ct = ContentTypeBuilder.CreateBasicContentType("test", "Test");
+            var ct = ContentTypeBuilder.CreateBasicContentType("test", "Test");
             ContentTypeRepository.Save(ct);
             var content = new Content("test", -1, ct) { CreatorId = 0, WriterId = 0 };
             DocumentRepository.Save(content);
             scope.Complete();
             efCoreScope.Complete();
-            return content.Id;
+            return (content, ct);
         }
     }
 
     [Test]
-    public async Task Can_Create_And_Get_By_Id()
+    public async Task Can_Create_And_Get_By_Key()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var content = (await CreateTestDataAsync("en-AU")).Content;
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            var content = DocumentRepository.Get(contentId);
+        var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
 
-            var domain = (IDomain)new UmbracoDomain("test.com") { RootContentId = content.Id, LanguageId = lang.Id };
-            repo.Save(domain);
+        var domain = (IDomain)new UmbracoDomain("test.com") { RootContentId = content.Id, LanguageId = lang!.Id };
+        await DomainRepository.SaveAsync(domain, CancellationToken.None);
 
-            // re-get
-            domain = repo.Get(domain.Id);
-
-            Assert.NotNull(domain);
-            Assert.IsTrue(domain.HasIdentity);
-            Assert.Greater(domain.Id, 0);
-            Assert.AreEqual("test.com", domain.DomainName);
-            Assert.AreEqual(content.Id, domain.RootContentId);
-            Assert.AreEqual(lang.Id, domain.LanguageId);
-            Assert.AreEqual(lang.IsoCode, domain.LanguageIsoCode);
-        }
+        // re-get by key
+        domain = await DomainRepository.GetAsync(domain.Key, CancellationToken.None);
+
+        Assert.NotNull(domain);
+        Assert.IsTrue(domain!.HasIdentity);
+        Assert.Greater(domain.Id, 0);
+        Assert.AreEqual("test.com", domain.DomainName);
+        Assert.AreEqual(content.Id, domain.RootContentId);
+        Assert.AreEqual(content.Key, domain.RootContentKey);
+        Assert.AreEqual(lang.Id, domain.LanguageId);
+        Assert.AreEqual(lang.IsoCode, domain.LanguageIsoCode);
+
+        efCoreScope.Complete();
     }
 
     [Test]
-    public void Can_Create_And_Get_By_Id_Empty_lang()
+    public async Task Can_Create_And_Get_By_Key_Empty_Lang()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var content = (await CreateTestDataAsync("en-AU")).Content;
 
-        var provider = ScopeProvider;
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
+        using var efCoreScope = NewScopeProvider.CreateScope();
 
-            var content = DocumentRepository.Get(contentId);
+        var domain = (IDomain)new UmbracoDomain("test.com") { RootContentId = content.Id };
+        await DomainRepository.SaveAsync(domain, CancellationToken.None);
 
-            var domain = (IDomain)new UmbracoDomain("test.com") { RootContentId = content.Id };
-            repo.Save(domain);
+        // re-get by key
+        domain = await DomainRepository.GetAsync(domain.Key, CancellationToken.None);
 
-            // re-get
-            domain = repo.Get(domain.Id);
-
-            Assert.NotNull(domain);
-            Assert.IsTrue(domain.HasIdentity);
-            Assert.Greater(domain.Id, 0);
-            Assert.AreEqual("test.com", domain.DomainName);
-            Assert.AreEqual(content.Id, domain.RootContentId);
-            Assert.IsFalse(domain.LanguageId.HasValue);
-        }
+        Assert.NotNull(domain);
+        Assert.IsTrue(domain!.HasIdentity);
+        Assert.Greater(domain.Id, 0);
+        Assert.AreEqual("test.com", domain.DomainName);
+        Assert.AreEqual(content.Id, domain.RootContentId);
+        Assert.IsFalse(domain.LanguageId.HasValue);
+
+        efCoreScope.Complete();
     }
 
     [Test]
     public async Task Cant_Create_Duplicate_Domain_Name()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var content = (await CreateTestDataAsync("en-AU")).Content;
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            var content = DocumentRepository.Get(contentId);
+        var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
 
-            var domain1 = (IDomain)new UmbracoDomain("test.com") { RootContentId = content.Id, LanguageId = lang.Id };
-            repo.Save(domain1);
+        var domain1 = (IDomain)new UmbracoDomain("test.com") { RootContentId = content.Id, LanguageId = lang!.Id };
+        await DomainRepository.SaveAsync(domain1, CancellationToken.None);
 
-            var domain2 = (IDomain)new UmbracoDomain("test.com") { RootContentId = content.Id, LanguageId = lang.Id };
+        var domain2 = (IDomain)new UmbracoDomain("test.com") { RootContentId = content.Id, LanguageId = lang.Id };
 
-            Assert.Throws<DuplicateNameException>(() => repo.Save(domain2));
-        }
+        Assert.ThrowsAsync<DuplicateNameException>(() => DomainRepository.SaveAsync(domain2, CancellationToken.None));
+
+        efCoreScope.Complete();
     }
 
     [Test]
     public async Task Can_Delete()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var content = (await CreateTestDataAsync("en-AU")).Content;
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            var content = DocumentRepository.Get(contentId);
+        var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
 
-            var domain = (IDomain)new UmbracoDomain("test.com") { RootContentId = content.Id, LanguageId = lang.Id };
-            repo.Save(domain);
+        var domain = (IDomain)new UmbracoDomain("test.com") { RootContentId = content.Id, LanguageId = lang!.Id };
+        await DomainRepository.SaveAsync(domain, CancellationToken.None);
 
-            repo.Delete(domain);
+        await DomainRepository.DeleteAsync(domain, CancellationToken.None);
 
-            // re-get
-            domain = repo.Get(domain.Id);
+        // re-get
+        domain = await DomainRepository.GetAsync(domain.Key, CancellationToken.None);
 
-            Assert.IsNull(domain);
-        }
+        Assert.IsNull(domain);
+
+        efCoreScope.Complete();
     }
 
     [Test]
     public async Task Can_Update()
     {
-        var contentId1 = CreateTestData("en-AU", out var ct);
+        var (content1, ct) = await CreateTestDataAsync("en-AU");
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var content1 = DocumentRepository.Get(contentId1);
+        // more test data
+        var lang1 = await LanguageRepository.GetByIsoCodeAsync("en-AU");
+        var lang2 = new Language("es", "Spanish");
+        await LanguageRepository.SaveAsync(lang2, CancellationToken.None);
 
-            // more test data
-            var lang1 = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            var globalSettings = new GlobalSettings();
-            var lang2 = new Language("es", "Spanish");
-            await LanguageRepository.SaveAsync(lang2, CancellationToken.None);
+        using (var scope = ScopeProvider.CreateScope())
+        {
             var content2 = new Content("test", -1, ct) { CreatorId = 0, WriterId = 0 };
             DocumentRepository.Save(content2);
+            scope.Complete();
 
-            var domain = (IDomain)new UmbracoDomain("test.com") { RootContentId = content1.Id, LanguageId = lang1.Id };
-            repo.Save(domain);
+            var domain = (IDomain)new UmbracoDomain("test.com") { RootContentId = content1.Id, LanguageId = lang1!.Id };
+            await DomainRepository.SaveAsync(domain, CancellationToken.None);
 
             // re-get
-            domain = repo.Get(domain.Id);
+            domain = (await DomainRepository.GetAsync(domain.Key, CancellationToken.None))!;
 
             domain.DomainName = "blah.com";
             domain.RootContentId = content2.Id;
             domain.LanguageId = lang2.Id;
-            repo.Save(domain);
+            await DomainRepository.SaveAsync(domain, CancellationToken.None);
 
             // re-get
-            domain = repo.Get(domain.Id);
+            domain = (await DomainRepository.GetAsync(domain.Key, CancellationToken.None))!;
 
             Assert.AreEqual("blah.com", domain.DomainName);
             Assert.AreEqual(content2.Id, domain.RootContentId);
             Assert.AreEqual(lang2.Id, domain.LanguageId);
             Assert.AreEqual(lang2.IsoCode, domain.LanguageIsoCode);
         }
+
+        efCoreScope.Complete();
     }
 
     [Test]
     public async Task Exists()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var content = (await CreateTestDataAsync("en-AU")).Content;
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            var content = DocumentRepository.Get(contentId);
+        var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
 
-            for (var i = 0; i < 10; i++)
-            {
-                var domain =
-                    (IDomain)new UmbracoDomain("test" + i + ".com") { RootContentId = content.Id, LanguageId = lang.Id };
-                repo.Save(domain);
-            }
+        for (var i = 0; i < 10; i++)
+        {
+            var domain = (IDomain)new UmbracoDomain("test" + i + ".com") { RootContentId = content.Id, LanguageId = lang!.Id };
+            await DomainRepository.SaveAsync(domain, CancellationToken.None);
+        }
 
-            var found = repo.Exists("test1.com");
+        var found = await DomainRepository.ExistsAsync("test1.com");
 
-            Assert.IsTrue(found);
-        }
+        Assert.IsTrue(found);
+
+        efCoreScope.Complete();
     }
 
     [Test]
     public async Task Get_By_Name()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var content = (await CreateTestDataAsync("en-AU")).Content;
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            var content = DocumentRepository.Get(contentId);
+        var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
 
-            for (var i = 0; i < 10; i++)
-            {
-                var domain =
-                    (IDomain)new UmbracoDomain("test" + i + ".com") { RootContentId = content.Id, LanguageId = lang.Id };
-                repo.Save(domain);
-            }
+        for (var i = 0; i < 10; i++)
+        {
+            var domain = (IDomain)new UmbracoDomain("test" + i + ".com") { RootContentId = content.Id, LanguageId = lang!.Id };
+            await DomainRepository.SaveAsync(domain, CancellationToken.None);
+        }
 
-            var found = repo.GetByName("test1.com");
+        var found = await DomainRepository.GetByNameAsync("test1.com");
 
-            Assert.IsNotNull(found);
-        }
+        Assert.IsNotNull(found);
+
+        efCoreScope.Complete();
     }
 
     [Test]
     public async Task Get_All()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var content = (await CreateTestDataAsync("en-AU")).Content;
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            var content = DocumentRepository.Get(contentId);
+        var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
 
-            for (var i = 0; i < 10; i++)
-            {
-                var domain =
-                    (IDomain)new UmbracoDomain("test " + i + ".com") { RootContentId = content.Id, LanguageId = lang.Id };
-                repo.Save(domain);
-            }
+        for (var i = 0; i < 10; i++)
+        {
+            var domain = (IDomain)new UmbracoDomain("test " + i + ".com") { RootContentId = content.Id, LanguageId = lang!.Id };
+            await DomainRepository.SaveAsync(domain, CancellationToken.None);
+        }
 
-            var all = repo.GetMany();
+        var all = await DomainRepository.GetAllAsync(CancellationToken.None);
 
-            Assert.AreEqual(10, all.Count());
-        }
+        Assert.AreEqual(10, all.Count());
+
+        efCoreScope.Complete();
     }
 
     [Test]
-    public async Task Get_All_Ids()
+    public async Task Get_Many_By_Keys()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var content = (await CreateTestDataAsync("en-AU")).Content;
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            var content = DocumentRepository.Get(contentId);
+        var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
 
-            var ids = new List<int>();
-            for (var i = 0; i < 10; i++)
-            {
-                var domain =
-                    (IDomain)new UmbracoDomain("test " + i + ".com") { RootContentId = content.Id, LanguageId = lang.Id };
-                repo.Save(domain);
-                ids.Add(domain.Id);
-            }
+        var keys = new List<Guid>();
+        for (var i = 0; i < 10; i++)
+        {
+            var domain = (IDomain)new UmbracoDomain("test " + i + ".com") { RootContentId = content.Id, LanguageId = lang!.Id };
+            await DomainRepository.SaveAsync(domain, CancellationToken.None);
+            keys.Add(domain.Key);
+        }
 
-            var all = repo.GetMany(ids.Take(8).ToArray());
+        var all = await DomainRepository.GetManyAsync(keys.Take(8).ToArray(), CancellationToken.None);
 
-            Assert.AreEqual(8, all.Count());
-        }
+        Assert.AreEqual(8, all.Count());
+
+        efCoreScope.Complete();
     }
 
     [Test]
     public async Task Get_All_Without_Wildcards()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var content = (await CreateTestDataAsync("en-AU")).Content;
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            var content = DocumentRepository.Get(contentId);
+        var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
 
-            for (var i = 0; i < 10; i++)
+        for (var i = 0; i < 10; i++)
+        {
+            var domain = (IDomain)new UmbracoDomain(i % 2 == 0 ? "test " + i + ".com" : "*" + i)
             {
-                var domain = (IDomain)new UmbracoDomain(i % 2 == 0 ? "test " + i + ".com" : "*" + i)
-                {
-                    RootContentId = content.Id,
-                    LanguageId = lang.Id
-                };
-                repo.Save(domain);
-            }
+                RootContentId = content.Id,
+                LanguageId = lang!.Id
+            };
+            await DomainRepository.SaveAsync(domain, CancellationToken.None);
+        }
 
-            var all = repo.GetAll(false);
+        var all = await DomainRepository.GetAllAsync(false);
 
-            Assert.AreEqual(5, all.Count());
-        }
+        Assert.AreEqual(5, all.Count());
+
+        efCoreScope.Complete();
     }
 
     [Test]
     public async Task Get_All_For_Content()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var (content, ct) = await CreateTestDataAsync("en-AU");
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var contentItems = new List<IContent>();
+        var contentItems = new List<IContent> { content };
 
-            var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            contentItems.Add(DocumentRepository.Get(contentId));
+        var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
 
-            // more test data (3 content items total)
+        // more test data (3 content items total)
+        using (var scope = ScopeProvider.CreateScope())
+        {
             for (var i = 0; i < 2; i++)
             {
                 var c = new Content("test" + i, -1, ct) { CreatorId = 0, WriterId = 0 };
@@ -368,44 +311,45 @@ public async Task Get_All_For_Content()
                 contentItems.Add(c);
             }
 
-            for (var i = 0; i < 10; i++)
+            scope.Complete();
+        }
+
+        for (var i = 0; i < 10; i++)
+        {
+            var domain = (IDomain)new UmbracoDomain(i % 2 == 0 ? "test " + i + ".com" : "*" + i)
             {
-                var domain = (IDomain)new UmbracoDomain(i % 2 == 0 ? "test " + i + ".com" : "*" + i)
-                {
-                    RootContentId = (i % 2 == 0 ? contentItems[0] : contentItems[1]).Id,
-                    LanguageId = lang.Id
-                };
-                repo.Save(domain);
-            }
+                RootContentId = (i % 2 == 0 ? contentItems[0] : contentItems[1]).Id,
+                LanguageId = lang!.Id
+            };
+            await DomainRepository.SaveAsync(domain, CancellationToken.None);
+        }
 
-            var all1 = repo.GetAssignedDomains(contentItems[0].Id, true);
-            Assert.AreEqual(5, all1.Count());
+        var all1 = await DomainRepository.GetAssignedDomainsAsync(contentItems[0].Key, true);
+        Assert.AreEqual(5, all1.Count());
 
-            var all2 = repo.GetAssignedDomains(contentItems[1].Id, true);
-            Assert.AreEqual(5, all2.Count());
+        var all2 = await DomainRepository.GetAssignedDomainsAsync(contentItems[1].Key, true);
+        Assert.AreEqual(5, all2.Count());
 
-            var all3 = repo.GetAssignedDomains(contentItems[2].Id, true);
-            Assert.AreEqual(0, all3.Count());
-        }
+        var all3 = await DomainRepository.GetAssignedDomainsAsync(contentItems[2].Key, true);
+        Assert.AreEqual(0, all3.Count());
+
+        efCoreScope.Complete();
     }
 
     [Test]
     public async Task Get_All_For_Content_Without_Wildcards()
     {
-        var contentId = CreateTestData("en-AU", out var ct);
+        var (content, ct) = await CreateTestDataAsync("en-AU");
 
-        var provider = ScopeProvider;
         using var efCoreScope = NewScopeProvider.CreateScope();
-        using (var scope = provider.CreateScope())
-        {
-            var repo = CreateRepository(provider);
 
-            var contentItems = new List<IContent>();
+        var contentItems = new List<IContent> { content };
 
-            var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
-            contentItems.Add(DocumentRepository.Get(contentId));
+        var lang = await LanguageRepository.GetByIsoCodeAsync("en-AU");
 
-            // more test data (3 content items total)
+        // more test data (3 content items total)
+        using (var scope = ScopeProvider.CreateScope())
+        {
             for (var i = 0; i < 2; i++)
             {
                 var c = new Content("test" + i, -1, ct) { CreatorId = 0, WriterId = 0 };
@@ -413,21 +357,25 @@ public async Task Get_All_For_Content_Without_Wildcards()
                 contentItems.Add(c);
             }
 
-            for (var i = 0; i < 10; i++)
+            scope.Complete();
+        }
+
+        for (var i = 0; i < 10; i++)
+        {
+            var domain = (IDomain)new UmbracoDomain(i % 2 == 0 ? "test " + i + ".com" : "*" + i)
             {
-                var domain = (IDomain)new UmbracoDomain(i % 2 == 0 ? "test " + i + ".com" : "*" + i)
-                {
-                    RootContentId = (i % 2 == 0 ? contentItems[0] : contentItems[1]).Id,
-                    LanguageId = lang.Id
-                };
-                repo.Save(domain);
-            }
+                RootContentId = (i % 2 == 0 ? contentItems[0] : contentItems[1]).Id,
+                LanguageId = lang!.Id
+            };
+            await DomainRepository.SaveAsync(domain, CancellationToken.None);
+        }
 
-            var all1 = repo.GetAssignedDomains(contentItems[0].Id, false);
-            Assert.AreEqual(5, all1.Count());
+        var all1 = await DomainRepository.GetAssignedDomainsAsync(contentItems[0].Key, false);
+        Assert.AreEqual(5, all1.Count());
 
-            var all2 = repo.GetAssignedDomains(contentItems[1].Id, false);
-            Assert.AreEqual(0, all2.Count());
-        }
+        var all2 = await DomainRepository.GetAssignedDomainsAsync(contentItems[1].Key, false);
+        Assert.AreEqual(0, all2.Count());
+
+        efCoreScope.Complete();
     }
 }
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/ElementVersionRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/ElementVersionRepositoryTest.cs
index 3dae61f662b3..cfdf70c290e1 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/ElementVersionRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/ElementVersionRepositoryTest.cs
@@ -37,7 +37,7 @@ public void GetElementVersionsEligibleForCleanup_Always_ExcludesActiveVersions()
         using (ScopeProvider.CreateScope())
         {
             var sut = new ElementVersionRepository(ScopeAccessor);
-            var results = sut.GetContentVersionsEligibleForCleanup();
+            var results = sut.GetContentVersionsEligibleForCleanup(DateTime.UtcNow.AddDays(1), null);
 
             Assert.Multiple(() =>
             {
@@ -71,7 +71,7 @@ public void GetElementVersionsEligibleForCleanup_Always_ExcludesPinnedVersions()
             ScopeAccessor.AmbientScope.Database.Update<ContentVersionDto>("set preventCleanup = 1 where id in (1,3)");
 
             var sut = new ElementVersionRepository(ScopeAccessor);
-            var results = sut.GetContentVersionsEligibleForCleanup();
+            var results = sut.GetContentVersionsEligibleForCleanup(DateTime.UtcNow.AddDays(1), null);
 
             Assert.Multiple(() =>
             {
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/MediaTypeRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/MediaTypeRepositoryTest.cs
index f5551d751a62..25d8c17ff24a 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/MediaTypeRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/MediaTypeRepositoryTest.cs
@@ -412,6 +412,41 @@ public void Can_Verify_PropertyTypes_On_File_MediaType()
         }
     }
 
+    [Test]
+    public void Get_By_Guid_Returns_Deep_Clone_Not_Cached_Instance()
+    {
+        var provider = ScopeProvider;
+        using (var scope = provider.CreateScope())
+        {
+            var repository = CreateRepository(provider);
+            IMediaType mediaType = MediaTypeBuilder.CreateNewMediaType();
+            repository.Save(mediaType);
+
+            var first = repository.Get(mediaType.Key);
+            var second = repository.Get(mediaType.Key);
+
+            Assert.IsNotNull(first);
+            Assert.IsNotNull(second);
+            Assert.AreEqual(first.Id, second.Id);
+            Assert.AreNotSame(first, second);
+        }
+    }
+
+    [Test]
+    public void Exists_By_Guid_Returns_Correct_Result()
+    {
+        var provider = ScopeProvider;
+        using (var scope = provider.CreateScope())
+        {
+            var repository = CreateRepository(provider);
+            IMediaType mediaType = MediaTypeBuilder.CreateNewMediaType();
+            repository.Save(mediaType);
+
+            Assert.IsTrue(repository.Exists(mediaType.Key));
+            Assert.IsFalse(repository.Exists(Guid.NewGuid()));
+        }
+    }
+
     private MediaTypeRepository CreateRepository(IScopeProvider provider) =>
         new((IScopeAccessor)provider, AppCaches.Disabled, LoggerFactory.CreateLogger<MediaTypeRepository>(), CommonRepository, LanguageRepository, ShortStringHelper, Mock.Of<IRepositoryCacheVersionService>(), IdKeyMap, Mock.Of<ICacheSyncService>());
 
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/MemberRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/MemberRepositoryTest.cs
index 8129c2a10537..e4ae6ff48661 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/MemberRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/MemberRepositoryTest.cs
@@ -71,9 +71,9 @@ private MemberRepository CreateRepository(IScopeProvider provider)
             DataTypeService,
             JsonSerializer,
             Mock.Of<IEventAggregator>(),
-            Options.Create(new MemberPasswordConfigurationSettings()),
             Mock.Of<IRepositoryCacheVersionService>(),
-            Mock.Of<ICacheSyncService>());
+            Mock.Of<ICacheSyncService>(),
+            Options.Create(new SecuritySettings()));
     }
 
     [Test]
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RedirectUrlRepositoryTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RedirectUrlRepositoryTests.cs
index 4b694f1b9c44..efb5c0313c3c 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RedirectUrlRepositoryTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RedirectUrlRepositoryTests.cs
@@ -4,6 +4,7 @@
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Cache;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Persistence.Repositories;
@@ -21,7 +22,7 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Persistence.Repos
 internal sealed class RedirectUrlRepositoryTests : UmbracoIntegrationTest
 {
     [SetUp]
-    public void SetUp() => CreateTestData();
+    public async Task SetUp() => await CreateTestDataAsync();
 
     [Test]
     public void Can_Save_And_Get()
@@ -355,11 +356,11 @@ private IRedirectUrlRepository CreateRepository(IScopeProvider provider) =>
     private IContent _otherpage;
     private IContent _trashed;
 
-    public void CreateTestData()
+    public async Task CreateTestDataAsync()
     {
-        var fileService = GetRequiredService<IFileService>();
+        var templateService = GetRequiredService<ITemplateService>();
         var template = TemplateBuilder.CreateTextPageTemplate();
-        fileService.SaveTemplate(template); // else, FK violation on contentType!
+        await templateService.CreateAsync(template, Constants.Security.SuperUserKey); // else, FK violation on contentType!
 
         var contentService = GetRequiredService<IContentService>();
         var contentTypeService = GetRequiredService<IContentTypeService>();
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationRepositoryTest.cs
index 85aa7b0fc817..eb5463d40967 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationRepositoryTest.cs
@@ -25,7 +25,7 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Persistence.Repos
 internal sealed class RelationRepositoryTest : UmbracoIntegrationTest
 {
     [SetUp]
-    public void SetUp() => CreateTestData();
+    public async Task SetUp() => await CreateTestDataAsync();
 
     private RelationType _relateContent;
     private RelationType _relateContentType;
@@ -50,8 +50,6 @@ internal sealed class RelationRepositoryTest : UmbracoIntegrationTest
 
     private IRelationService RelationService => GetRequiredService<IRelationService>();
 
-    private IFileService FileService => GetRequiredService<IFileService>();
-
     private RelationRepository CreateRepository(IScopeProvider provider, out RelationTypeRepository relationTypeRepository)
     {
         relationTypeRepository = (RelationTypeRepository)GetRequiredService<IRelationTypeRepository>();
@@ -553,7 +551,7 @@ public void Can_Delete_Content_And_Verify_Relation_Is_Removed()
         }
     }
 
-    public void CreateTestData()
+    public async Task CreateTestDataAsync()
     {
         _relateContent = new RelationType(
             "Relate Content on Copy",
@@ -581,8 +579,9 @@ public void CreateTestData()
             relationTypeRepository.Save(_relateContent);
             relationTypeRepository.Save(_relateContentType);
 
+            var templateService = GetRequiredService<ITemplateService>();
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await templateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             // Create and Save ContentType "umbTextpage" -> (NodeDto.NodeIdSeed)
             _contentType =
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/TagRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/TagRepositoryTest.cs
index a6ae0e334e9c..d5c1f0a92901 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/TagRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/TagRepositoryTest.cs
@@ -4,6 +4,7 @@
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Cache;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Persistence.Repositories;
@@ -21,7 +22,7 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Persistence.Repos
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
 internal sealed class TagRepositoryTest : UmbracoIntegrationTest
 {
-    private IFileService FileService => GetRequiredService<IFileService>();
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
 
     private IContentTypeRepository ContentTypeRepository => GetRequiredService<IContentTypeRepository>();
 
@@ -70,7 +71,7 @@ public void Can_Perform_Multiple_Adds_On_Repository()
     }
 
     [Test]
-    public void Can_Create_Tag_Relations()
+    public async Task Can_Create_Tag_Relations()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -78,7 +79,7 @@ public void Can_Create_Tag_Relations()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -100,7 +101,7 @@ public void Can_Create_Tag_Relations()
     }
 
     [Test]
-    public void Can_Append_Tag_Relations()
+    public async Task Can_Append_Tag_Relations()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -108,7 +109,7 @@ public void Can_Append_Tag_Relations()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -137,7 +138,7 @@ public void Can_Append_Tag_Relations()
     }
 
     [Test]
-    public void Can_Replace_Tag_Relations()
+    public async Task Can_Replace_Tag_Relations()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -145,7 +146,7 @@ public void Can_Replace_Tag_Relations()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -176,7 +177,7 @@ public void Can_Replace_Tag_Relations()
     }
 
     [Test]
-    public void Can_Merge_Tag_Relations()
+    public async Task Can_Merge_Tag_Relations()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -184,7 +185,7 @@ public void Can_Merge_Tag_Relations()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -214,7 +215,7 @@ public void Can_Merge_Tag_Relations()
     }
 
     [Test]
-    public void Can_Clear_Tag_Relations()
+    public async Task Can_Clear_Tag_Relations()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -222,7 +223,7 @@ public void Can_Clear_Tag_Relations()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -250,7 +251,7 @@ public void Can_Clear_Tag_Relations()
     }
 
     [Test]
-    public void Can_Remove_Specific_Tags_From_Property()
+    public async Task Can_Remove_Specific_Tags_From_Property()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -258,7 +259,7 @@ public void Can_Remove_Specific_Tags_From_Property()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -293,7 +294,7 @@ public void Can_Remove_Specific_Tags_From_Property()
     }
 
     [Test]
-    public void Can_Get_Tags_For_Content_By_Id()
+    public async Task Can_Get_Tags_For_Content_By_Id()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -301,7 +302,7 @@ public void Can_Get_Tags_For_Content_By_Id()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -337,7 +338,7 @@ public void Can_Get_Tags_For_Content_By_Id()
     }
 
     [Test]
-    public void Can_Get_Tags_For_Content_By_Key()
+    public async Task Can_Get_Tags_For_Content_By_Key()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -345,7 +346,7 @@ public void Can_Get_Tags_For_Content_By_Key()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -382,7 +383,7 @@ public void Can_Get_Tags_For_Content_By_Key()
     }
 
     [Test]
-    public void Can_Get_All()
+    public async Task Can_Get_All()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -390,7 +391,7 @@ public void Can_Get_All()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -419,7 +420,7 @@ public void Can_Get_All()
     }
 
     [Test]
-    public void Can_Get_All_With_Ids()
+    public async Task Can_Get_All_With_Ids()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -427,7 +428,7 @@ public void Can_Get_All_With_Ids()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -460,7 +461,7 @@ public void Can_Get_All_With_Ids()
     }
 
     [Test]
-    public void Can_Get_Tags_For_Content_For_Group()
+    public async Task Can_Get_Tags_For_Content_For_Group()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -468,7 +469,7 @@ public void Can_Get_Tags_For_Content_For_Group()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -504,7 +505,7 @@ public void Can_Get_Tags_For_Content_For_Group()
     }
 
     [Test]
-    public void Can_Get_Tags_For_Property_By_Id()
+    public async Task Can_Get_Tags_For_Property_By_Id()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -512,7 +513,7 @@ public void Can_Get_Tags_For_Property_By_Id()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -548,7 +549,7 @@ public void Can_Get_Tags_For_Property_By_Id()
     }
 
     [Test]
-    public void Can_Get_Tags_For_Property_By_Key()
+    public async Task Can_Get_Tags_For_Property_By_Key()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -556,7 +557,7 @@ public void Can_Get_Tags_For_Property_By_Key()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -593,7 +594,7 @@ public void Can_Get_Tags_For_Property_By_Key()
     }
 
     [Test]
-    public void Can_Get_Tags_For_Property_For_Group()
+    public async Task Can_Get_Tags_For_Property_For_Group()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -601,7 +602,7 @@ public void Can_Get_Tags_For_Property_For_Group()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -640,13 +641,13 @@ public void Can_Get_Tags_For_Property_For_Group()
     }
 
     [Test]
-    public void Can_Get_Tags_For_Entity_Type_Excluding_Trashed_Entity()
+    public async Task Can_Get_Tags_For_Entity_Type_Excluding_Trashed_Entity()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
         {
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType = ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
             ContentTypeRepository.Save(contentType);
@@ -723,7 +724,7 @@ public void Can_Get_Tags_For_Entity_Type_Excluding_Trashed_Entity()
     }
 
     [Test]
-    public void Can_Get_Tags_For_Entity_Type()
+    public async Task Can_Get_Tags_For_Entity_Type()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -731,7 +732,7 @@ public void Can_Get_Tags_For_Entity_Type()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -780,7 +781,7 @@ public void Can_Get_Tags_For_Entity_Type()
     }
 
     [Test]
-    public void Can_Get_Tags_For_Entity_Type_For_Group()
+    public async Task Can_Get_Tags_For_Entity_Type_For_Group()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -788,7 +789,7 @@ public void Can_Get_Tags_For_Entity_Type_For_Group()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -831,7 +832,7 @@ public void Can_Get_Tags_For_Entity_Type_For_Group()
     }
 
     [Test]
-    public void Cascade_Deletes_Tag_Relations()
+    public async Task Cascade_Deletes_Tag_Relations()
     {
         var provider = ScopeProvider;
         using (var scope = ScopeProvider.CreateScope())
@@ -839,7 +840,7 @@ public void Cascade_Deletes_Tag_Relations()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -869,7 +870,7 @@ public void Cascade_Deletes_Tag_Relations()
     }
 
     [Test]
-    public void Can_Get_Tagged_Entities_For_Tag_Group()
+    public async Task Can_Get_Tagged_Entities_For_Tag_Group()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -877,7 +878,7 @@ public void Can_Get_Tagged_Entities_For_Tag_Group()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -963,7 +964,7 @@ public void Can_Get_Tagged_Entities_For_Tag_Group()
     }
 
     [Test]
-    public void Can_Get_Tagged_Entities_For_Tag()
+    public async Task Can_Get_Tagged_Entities_For_Tag()
     {
         var provider = ScopeProvider;
         using (ScopeProvider.CreateScope())
@@ -971,7 +972,7 @@ public void Can_Get_Tagged_Entities_For_Tag()
             // create data to relate to
             // We have to create and save a template, otherwise we get an FK violation on contentType.
             var template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
@@ -1049,12 +1050,12 @@ public void Can_Get_Tagged_Entities_For_Tag()
     }
 
     [Test]
-    public void Can_Create_Tag_Relations_With_Mixed_Casing_For_Tag()
+    public async Task Can_Create_Tag_Relations_With_Mixed_Casing_For_Tag()
     {
         var provider = ScopeProvider;
         using (var scope = ScopeProvider.CreateScope())
         {
-            (IContentType contentType, IContent content1, IContent content2) = CreateContentForCreateTagTests();
+            (IContentType contentType, IContent content1, IContent content2) = await CreateContentForCreateTagTests();
 
             var repository = CreateRepository(provider);
 
@@ -1085,12 +1086,12 @@ public void Can_Create_Tag_Relations_With_Mixed_Casing_For_Tag()
     }
 
     [Test]
-    public void Can_Create_Tag_Relations_With_Mixed_Casing_For_Group()
+    public async Task Can_Create_Tag_Relations_With_Mixed_Casing_For_Group()
     {
         var provider = ScopeProvider;
         using (var scope = ScopeProvider.CreateScope())
         {
-            (IContentType contentType, IContent content1, IContent content2) = CreateContentForCreateTagTests();
+            (IContentType contentType, IContent content1, IContent content2) = await CreateContentForCreateTagTests();
 
             var repository = CreateRepository(provider);
 
@@ -1124,10 +1125,10 @@ public void Can_Create_Tag_Relations_With_Mixed_Casing_For_Group()
         }
     }
 
-    private (IContentType ContentType, IContent Content1, IContent Content2) CreateContentForCreateTagTests()
+    private async Task<(IContentType ContentType, IContent Content1, IContent Content2)> CreateContentForCreateTagTests()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType("test", "Test", defaultTemplateId: template.Id);
         ContentTypeRepository.Save(contentType);
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/TemplateRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/TemplateRepositoryTest.cs
index ea9a5bc869c3..623025f23bbf 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/TemplateRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/TemplateRepositoryTest.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using System.Text;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Options;
@@ -503,14 +502,14 @@ public void Can_Perform_Delete_View()
     }
 
     [Test]
-    public void Can_Perform_Delete_When_Assigned_To_Doc()
+    public async Task Can_Perform_Delete_When_Assigned_To_Doc()
     {
         // Arrange
         var newScopeAccessor = GetRequiredService<IEFCoreScopeAccessor<UmbracoDbContext>>();
         var provider = ScopeProvider;
         var scopeAccessor = (IScopeAccessor)provider;
         var dataTypeService = GetRequiredService<IDataTypeService>();
-        var fileService = GetRequiredService<IFileService>();
+        var templateService = GetRequiredService<ITemplateService>();
 
         using (provider.CreateScope())
         {
@@ -549,7 +548,7 @@ public void Can_Perform_Delete_When_Assigned_To_Doc()
                 Mock.Of<ICacheSyncService>());
 
             var template = TemplateBuilder.CreateTextPageTemplate();
-            fileService.SaveTemplate(template); // else, FK violation on contentType!
+            await templateService.CreateAsync(template, Constants.Security.SuperUserKey); // else, FK violation on contentType!
 
             var contentType =
                 ContentTypeBuilder.CreateSimpleContentType("umbTextpage2", "Textpage", defaultTemplateId: template.Id);
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/UserRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/UserRepositoryTest.cs
index 8f676ac4adc1..3d7002c5249a 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/UserRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/UserRepositoryTest.cs
@@ -52,7 +52,7 @@ private UserRepository CreateRepository(ICoreScopeProvider provider)
             LoggerFactory.CreateLogger<UserRepository>(),
             Mappers,
             Options.Create(GlobalSettings),
-            Options.Create(new UserPasswordConfigurationSettings()),
+            Options.Create(new SecuritySettings()),
             new SystemTextJsonSerializer(new DefaultJsonSerializerEncoderFactory()),
             mockRuntimeState.Object,
             Mock.Of<IRepositoryCacheVersionService>(),
@@ -169,7 +169,7 @@ public void Can_Perform_Delete_On_UserRepository()
                 LoggerFactory.CreateLogger<UserRepository>(),
                 Mock.Of<IMapperCollection>(),
                 Options.Create(GlobalSettings),
-                Options.Create(new UserPasswordConfigurationSettings()),
+                Options.Create(new SecuritySettings()),
                 new SystemTextJsonSerializer(new DefaultJsonSerializerEncoderFactory()),
                 mockRuntimeState.Object,
                 Mock.Of<IRepositoryCacheVersionService>(),
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/PropertyEditors/BlockEditorBackwardsCompatibilityTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/PropertyEditors/BlockEditorBackwardsCompatibilityTests.cs
index ea8d586f3487..38ca8474435d 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/PropertyEditors/BlockEditorBackwardsCompatibilityTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/PropertyEditors/BlockEditorBackwardsCompatibilityTests.cs
@@ -26,257 +26,6 @@ internal sealed class BlockEditorBackwardsCompatibilityTests : UmbracoIntegratio
 
     private IConfigurationEditorJsonSerializer ConfigurationEditorJsonSerializer => GetRequiredService<IConfigurationEditorJsonSerializer>();
 
-    [TestCase]
-    public async Task BlockListIsBackwardsCompatible()
-    {
-        var elementType = await CreateElementType();
-        var blockListDataType = await CreateBlockListDataType(elementType);
-        var contentType = await CreateContentType(blockListDataType);
-
-        var json = $$"""
-                     {
-                         "layout": {
-                             "{{Constants.PropertyEditors.Aliases.BlockList}}": [
-                                 {
-                                     "contentUdi": "umb://element/1304e1ddac87439684fe8a399231cb3d",
-                                     "settingsUdi": "umb://element/1f613e26ce274898908a561437af5100"
-                                 },
-                                 {
-                                     "contentUdi": "umb://element/0a4a416e547d464fabcc6f345c17809a",
-                                     "settingsUdi": "umb://element/63027539b0db45e7b70459762d4e83dd"
-                                 }
-                             ]
-                         },
-                         "contentData": [
-                             {
-                                 "contentTypeKey": "{{elementType.Key}}",
-                                 "udi": "umb://element/1304e1ddac87439684fe8a399231cb3d",
-                                 "title": "Content Title One",
-                                 "text": "Content Text One"
-                             },
-                             {
-                                 "contentTypeKey": "{{elementType.Key}}",
-                                 "udi": "umb://element/0a4a416e547d464fabcc6f345c17809a",
-                                 "title": "Content Title Two",
-                                 "text": "Content Text Two"
-                             }
-                         ],
-                         "settingsData": [
-                             {
-                                 "contentTypeKey": "{{elementType.Key}}",
-                                 "udi": "umb://element/1f613e26ce274898908a561437af5100",
-                                 "title": "Settings Title One",
-                                 "text": "Settings Text One"
-                             },
-                             {
-                                 "contentTypeKey": "{{elementType.Key}}",
-                                 "udi": "umb://element/63027539b0db45e7b70459762d4e83dd",
-                                 "title": "Settings Title Two",
-                                 "text": "Settings Text Two"
-                             }
-                         ]
-                     }
-                     """;
-
-        var contentBuilder = new ContentBuilder()
-            .WithContentType(contentType)
-            .WithName("Home");
-
-        var content = contentBuilder.Build();
-        content.Properties["blocks"]!.SetValue(json);
-        ContentService.Save(content);
-
-        var toEditor = blockListDataType.Editor!.GetValueEditor().ToEditor(content.Properties["blocks"]!) as BlockListValue;
-        Assert.IsNotNull(toEditor);
-
-        Assert.Multiple(() =>
-        {
-            Assert.AreEqual(2, toEditor.ContentData.Count);
-
-            Assert.AreEqual("1304e1ddac87439684fe8a399231cb3d", toEditor.ContentData[0].Key.ToString("N"));
-            Assert.AreEqual("0a4a416e547d464fabcc6f345c17809a", toEditor.ContentData[1].Key.ToString("N"));
-
-            AssertValueEquals(toEditor.ContentData[0], "title", "Content Title One");
-            AssertValueEquals(toEditor.ContentData[0], "text", "Content Text One");
-            AssertValueEquals(toEditor.ContentData[1], "title", "Content Title Two");
-            AssertValueEquals(toEditor.ContentData[1], "text", "Content Text Two");
-
-            Assert.IsFalse(toEditor.ContentData[0].RawPropertyValues.Any());
-            Assert.IsFalse(toEditor.ContentData[1].RawPropertyValues.Any());
-        });
-
-        Assert.Multiple(() =>
-        {
-            Assert.AreEqual(2, toEditor.SettingsData.Count);
-
-            Assert.AreEqual("1f613e26ce274898908a561437af5100", toEditor.SettingsData[0].Key.ToString("N"));
-            Assert.AreEqual("63027539b0db45e7b70459762d4e83dd", toEditor.SettingsData[1].Key.ToString("N"));
-
-            AssertValueEquals(toEditor.SettingsData[0], "title", "Settings Title One");
-            AssertValueEquals(toEditor.SettingsData[0], "text", "Settings Text One");
-            AssertValueEquals(toEditor.SettingsData[1], "title", "Settings Title Two");
-            AssertValueEquals(toEditor.SettingsData[1], "text", "Settings Text Two");
-
-            Assert.IsFalse(toEditor.SettingsData[0].RawPropertyValues.Any());
-            Assert.IsFalse(toEditor.SettingsData[1].RawPropertyValues.Any());
-        });
-
-        Assert.Multiple(() =>
-        {
-            Assert.AreEqual(2, toEditor.Expose.Count);
-
-            Assert.AreEqual("1304e1ddac87439684fe8a399231cb3d", toEditor.Expose[0].ContentKey.ToString("N"));
-            Assert.AreEqual("0a4a416e547d464fabcc6f345c17809a", toEditor.Expose[1].ContentKey.ToString("N"));
-        });
-    }
-
-    [TestCase]
-    public async Task BlockGridIsBackwardsCompatible()
-    {
-        var elementType = await CreateElementType();
-        var gridAreaKey = Guid.NewGuid();
-        var blockGridDataType = await CreateBlockGridDataType(elementType, gridAreaKey);
-        var contentType = await CreateContentType(blockGridDataType);
-
-        var json = $$"""
-                     {
-                         "layout": {
-                             "{{Constants.PropertyEditors.Aliases.BlockGrid}}": [
-                                 {
-                                     "contentUdi": "umb://element/1304e1ddac87439684fe8a399231cb3d",
-                                     "settingsUdi": "umb://element/1f613e26ce274898908a561437af5100",
-                                     "columnSpan": 12,
-                                     "rowSpan": 1,
-                                     "areas": [{
-                                        "key": "{{gridAreaKey}}",
-                                        "items": [{
-                                           "contentUdi": "umb://element/5fc866c590be4d01a28a979472a1ffee",
-                                           "areas": [],
-                                           "columnSpan": 12,
-                                           "rowSpan": 1
-                                        }]
-                                    }]
-                                 },
-                                 {
-                                     "contentUdi": "umb://element/0a4a416e547d464fabcc6f345c17809a",
-                                     "settingsUdi": "umb://element/63027539b0db45e7b70459762d4e83dd",
-                                     "columnSpan": 12,
-                                     "rowSpan": 1,
-                                     "areas": [{
-                                        "key": "{{gridAreaKey}}",
-                                        "items": [{
-                                           "contentUdi": "umb://element/264536b65b0f4641aa43d4bfb515831d",
-                                           "areas": [],
-                                           "columnSpan": 12,
-                                           "rowSpan": 1
-                                        }]
-                                    }]
-                                 }
-                             ]
-                         },
-                         "contentData": [
-                             {
-                                 "contentTypeKey": "{{elementType.Key}}",
-                                 "udi": "umb://element/1304e1ddac87439684fe8a399231cb3d",
-                                 "title": "Content Title One",
-                                 "text": "Content Text One"
-                             },
-                             {
-                                 "contentTypeKey": "{{elementType.Key}}",
-                                 "udi": "umb://element/0a4a416e547d464fabcc6f345c17809a",
-                                 "title": "Content Title Two",
-                                 "text": "Content Text Two"
-                             },
-                             {
-                                 "contentTypeKey": "{{elementType.Key}}",
-                                 "udi": "umb://element/5fc866c590be4d01a28a979472a1ffee",
-                                 "title": "Content Area Title One",
-                                 "text": "Content Area Text One"
-                             },
-                             {
-                                 "contentTypeKey": "{{elementType.Key}}",
-                                 "udi": "umb://element/264536b65b0f4641aa43d4bfb515831d",
-                                 "title": "Content Area Title Two",
-                                 "text": "Content Area Text Two"
-                             }
-                         ],
-                         "settingsData": [
-                             {
-                                 "contentTypeKey": "{{elementType.Key}}",
-                                 "udi": "umb://element/1f613e26ce274898908a561437af5100",
-                                 "title": "Settings Title One",
-                                 "text": "Settings Text One"
-                             },
-                             {
-                                 "contentTypeKey": "{{elementType.Key}}",
-                                 "udi": "umb://element/63027539b0db45e7b70459762d4e83dd",
-                                 "title": "Settings Title Two",
-                                 "text": "Settings Text Two"
-                             }
-                         ]
-                     }
-                     """;
-
-        var contentBuilder = new ContentBuilder()
-            .WithContentType(contentType)
-            .WithName("Home");
-
-        var content = contentBuilder.Build();
-        content.Properties["blocks"]!.SetValue(json);
-        ContentService.Save(content);
-
-        var toEditor = blockGridDataType.Editor!.GetValueEditor().ToEditor(content.Properties["blocks"]!) as BlockGridValue;
-        Assert.IsNotNull(toEditor);
-
-        Assert.AreEqual(4, toEditor.ContentData.Count);
-        Assert.Multiple(() =>
-        {
-            Assert.AreEqual("1304e1ddac87439684fe8a399231cb3d", toEditor.ContentData[0].Key.ToString("N"));
-            Assert.AreEqual("0a4a416e547d464fabcc6f345c17809a", toEditor.ContentData[1].Key.ToString("N"));
-            Assert.AreEqual("5fc866c590be4d01a28a979472a1ffee", toEditor.ContentData[2].Key.ToString("N"));
-            Assert.AreEqual("264536b65b0f4641aa43d4bfb515831d", toEditor.ContentData[3].Key.ToString("N"));
-
-            AssertValueEquals(toEditor.ContentData[0], "title", "Content Title One");
-            AssertValueEquals(toEditor.ContentData[0], "text", "Content Text One");
-            AssertValueEquals(toEditor.ContentData[1], "title", "Content Title Two");
-            AssertValueEquals(toEditor.ContentData[1], "text", "Content Text Two");
-            AssertValueEquals(toEditor.ContentData[2], "title", "Content Area Title One");
-            AssertValueEquals(toEditor.ContentData[2], "text", "Content Area Text One");
-            AssertValueEquals(toEditor.ContentData[3], "title", "Content Area Title Two");
-            AssertValueEquals(toEditor.ContentData[3], "text", "Content Area Text Two");
-
-            Assert.IsFalse(toEditor.ContentData[0].RawPropertyValues.Any());
-            Assert.IsFalse(toEditor.ContentData[1].RawPropertyValues.Any());
-            Assert.IsFalse(toEditor.ContentData[2].RawPropertyValues.Any());
-            Assert.IsFalse(toEditor.ContentData[3].RawPropertyValues.Any());
-        });
-
-        Assert.AreEqual(2, toEditor.SettingsData.Count);
-        Assert.Multiple(() =>
-        {
-            Assert.AreEqual("1f613e26ce274898908a561437af5100", toEditor.SettingsData[0].Key.ToString("N"));
-            Assert.AreEqual("63027539b0db45e7b70459762d4e83dd", toEditor.SettingsData[1].Key.ToString("N"));
-
-            AssertValueEquals(toEditor.SettingsData[0], "title", "Settings Title One");
-            AssertValueEquals(toEditor.SettingsData[0], "text", "Settings Text One");
-            AssertValueEquals(toEditor.SettingsData[1], "title", "Settings Title Two");
-            AssertValueEquals(toEditor.SettingsData[1], "text", "Settings Text Two");
-
-            Assert.IsFalse(toEditor.SettingsData[0].RawPropertyValues.Any());
-            Assert.IsFalse(toEditor.SettingsData[1].RawPropertyValues.Any());
-        });
-
-        Assert.Multiple(() =>
-        {
-            Assert.AreEqual(4, toEditor.Expose.Count);
-
-            Assert.AreEqual("1304e1ddac87439684fe8a399231cb3d", toEditor.Expose[0].ContentKey.ToString("N"));
-            Assert.AreEqual("0a4a416e547d464fabcc6f345c17809a", toEditor.Expose[1].ContentKey.ToString("N"));
-            Assert.AreEqual("5fc866c590be4d01a28a979472a1ffee", toEditor.Expose[2].ContentKey.ToString("N"));
-            Assert.AreEqual("264536b65b0f4641aa43d4bfb515831d", toEditor.Expose[3].ContentKey.ToString("N"));
-        });
-    }
-
     private static void AssertValueEquals(BlockItemData blockItemData, string propertyAlias, string expectedValue)
     {
         var blockPropertyValue = blockItemData.Values.FirstOrDefault(v => v.Alias == propertyAlias);
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/PropertyEditors/BlockGridNullSpanTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/PropertyEditors/BlockGridNullSpanTests.cs
new file mode 100644
index 000000000000..96f2f7a0f925
--- /dev/null
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/PropertyEditors/BlockGridNullSpanTests.cs
@@ -0,0 +1,97 @@
+using NUnit.Framework;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Blocks;
+using Umbraco.Cms.Core.PropertyEditors;
+using Umbraco.Cms.Core.Serialization;
+using Umbraco.Cms.Tests.Common.Builders;
+using Umbraco.Cms.Tests.Common.Builders.Extensions;
+
+namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.PropertyEditors;
+
+/// <summary>
+/// Regression test for https://github.com/umbraco/Umbraco-CMS/issues/22306
+/// BlockGrid throws "Nullable object must have a value" when a block item has null columnSpan/rowSpan.
+/// </summary>
+internal sealed class BlockGridNullSpanTests : BlockEditorElementVariationTestBase
+{
+    private IJsonSerializer JsonSerializer => GetRequiredService<IJsonSerializer>();
+
+    [Test]
+    public async Task Can_Render_BlockGrid_When_Items_Have_Null_Spans()
+    {
+        var elementType = CreateElementType(ContentVariation.Nothing);
+        var areaKey = Guid.NewGuid();
+
+        var blockGridDataType = await CreateBlockEditorDataType(
+            Constants.PropertyEditors.Aliases.BlockGrid,
+            new BlockGridConfiguration.BlockGridBlockConfiguration[]
+            {
+                new()
+                {
+                    ContentElementTypeKey = elementType.Key,
+                    AreaGridColumns = 12,
+                    Areas = [new() { Alias = "one", Key = areaKey, ColumnSpan = 12, RowSpan = 1 }],
+                },
+            });
+
+        var contentType = CreateContentType(ContentVariation.Nothing, blockGridDataType);
+
+        var rootKey = Guid.NewGuid();
+        var nestedKey = Guid.NewGuid();
+        var blockGridValue = new BlockGridValue(
+        [
+            new BlockGridLayoutItem(rootKey)
+            {
+                // Root item also has null spans to cover both code paths.
+                ColumnSpan = null,
+                RowSpan = null,
+                Areas =
+                [
+                    new BlockGridLayoutAreaItem(areaKey)
+                    {
+                        Items =
+                        [
+                            // Nested item with null spans — the scenario from issue #22306.
+                            new BlockGridLayoutItem(nestedKey) { ColumnSpan = null, RowSpan = null },
+                        ],
+                    },
+                ],
+            },
+        ])
+        {
+            ContentData =
+            [
+                new(rootKey, elementType.Key, elementType.Alias) { Values = [new() { Alias = "invariantText", Value = "Root" }] },
+                new(nestedKey, elementType.Key, elementType.Alias) { Values = [new() { Alias = "invariantText", Value = "Nested" }] },
+            ],
+            Expose = [new(rootKey, null, null), new(nestedKey, null, null)],
+        };
+
+        var content = new ContentBuilder().WithContentType(contentType).WithName("Home").Build();
+        content.Properties["blocks"]!.SetValue(JsonSerializer.Serialize(blockGridValue));
+        ContentService.Save(content);
+        PublishContent(content, ["*"]);
+
+        SetVariationContext(null, null);
+        var published = GetPublishedContent(content.Key);
+
+        // Before the fix this threw InvalidOperationException: "Nullable object must have a value".
+        var blocks = published.Value<BlockGridModel>("blocks");
+
+        Assert.IsNotNull(blocks);
+        Assert.AreEqual(1, blocks!.Count);
+
+        // Null RowSpan defaults to 1, null ColumnSpan defaults to gridColumns (12).
+        Assert.AreEqual(1, blocks[0].RowSpan);
+        Assert.AreEqual(12, blocks[0].ColumnSpan);
+
+        var area = blocks[0].Areas.FirstOrDefault();
+        Assert.IsNotNull(area);
+        Assert.AreEqual(1, area!.Count);
+
+        // Nested item gets the same defaults.
+        Assert.AreEqual(1, area[0].RowSpan);
+        Assert.AreEqual(12, area[0].ColumnSpan);
+    }
+}
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Routing/RedirectTrackerTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Routing/RedirectTrackerTests.cs
index e5383cf38a56..d023afbce6af 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Routing/RedirectTrackerTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Routing/RedirectTrackerTests.cs
@@ -27,9 +27,9 @@ public class RedirectTrackerTests : UmbracoIntegrationTestWithContent
     private IContent _rootPage;
     private IContent _testPage;
 
-    public override void CreateTestData()
+    public override async Task CreateTestDataAsync()
     {
-        base.CreateTestData();
+        await base.CreateTestDataAsync();
 
         var rootContent = ContentService.GetRootContent().First();
         _rootPage = rootContent;
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Scoping/NestedScopeTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Scoping/NestedScopeTests.cs
index 7a39f95093eb..218d998655ff 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Scoping/NestedScopeTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Scoping/NestedScopeTests.cs
@@ -27,11 +27,11 @@ internal sealed class NestedScopeTests : UmbracoIntegrationTest
 
         private ICoreScopeProvider CoreScopeProvider => Services.GetRequiredService<ICoreScopeProvider>();
 
-        private IEFCoreScopeProvider<TestUmbracoDbContext> EfCoreScopeProvider =>
+        private IEFCoreScopeProvider<TestUmbracoDbContext> EFCoreScopeProvider =>
             Services.GetRequiredService<IEFCoreScopeProvider<TestUmbracoDbContext>>();
 
         [Test]
-        public void CanNestScopes_Normal_Core_EfCore()
+        public void CanNestScopes_Normal_Core_EFCore()
         {
             using (var ambientScope = ScopeProvider.CreateScope())
             {
@@ -41,7 +41,7 @@ public void CanNestScopes_Normal_Core_EfCore()
                 {
                     outerScope.WriteLock(Constants.Locks.ContentTree);
 
-                    using (var innerScope = EfCoreScopeProvider.CreateScope())
+                    using (var innerScope = EFCoreScopeProvider.CreateScope())
                     {
                         innerScope.WriteLock(Constants.Locks.ContentTree);
 
@@ -54,13 +54,13 @@ public void CanNestScopes_Normal_Core_EfCore()
         }
 
         [Test]
-        public void CanNestScopes_Normal_EfCore_Core()
+        public void CanNestScopes_Normal_EFCore_Core()
         {
             using (var ambientScope = ScopeProvider.CreateScope())
             {
                 ambientScope.WriteLock(Constants.Locks.ContentTree);
 
-                using (var outerScope = EfCoreScopeProvider.CreateScope())
+                using (var outerScope = EFCoreScopeProvider.CreateScope())
                 {
                     outerScope.WriteLock(Constants.Locks.ContentTree);
 
@@ -77,7 +77,7 @@ public void CanNestScopes_Normal_EfCore_Core()
         }
 
         [Test]
-        public void CanNestScopes_Core_Normal_Efcore()
+        public void CanNestScopes_Core_Normal_EFCore()
         {
             using (var ambientScope = CoreScopeProvider.CreateCoreScope())
             {
@@ -87,7 +87,7 @@ public void CanNestScopes_Core_Normal_Efcore()
                 {
                     outerScope.WriteLock(Constants.Locks.ContentTree);
 
-                    using (var innerScope = EfCoreScopeProvider.CreateScope())
+                    using (var innerScope = EFCoreScopeProvider.CreateScope())
                     {
                         innerScope.WriteLock(Constants.Locks.ContentTree);
 
@@ -100,13 +100,13 @@ public void CanNestScopes_Core_Normal_Efcore()
         }
 
         [Test]
-        public void CanNestScopes_Core_EfCore_Normal()
+        public void CanNestScopes_Core_EFCore_Normal()
         {
             using (var ambientScope = CoreScopeProvider.CreateCoreScope())
             {
                 ambientScope.WriteLock(Constants.Locks.ContentTree);
 
-                using (var outerScope = EfCoreScopeProvider.CreateScope())
+                using (var outerScope = EFCoreScopeProvider.CreateScope())
                 {
                     outerScope.WriteLock(Constants.Locks.ContentTree);
 
@@ -123,9 +123,9 @@ public void CanNestScopes_Core_EfCore_Normal()
         }
 
         [Test]
-        public void CanNestScopes_EfCore_Normal_Core()
+        public void CanNestScopes_EFCore_Normal_Core()
         {
-            using (var ambientScope = EfCoreScopeProvider.CreateScope())
+            using (var ambientScope = EFCoreScopeProvider.CreateScope())
             {
                 ambientScope.WriteLock(Constants.Locks.ContentTree);
 
@@ -146,9 +146,9 @@ public void CanNestScopes_EfCore_Normal_Core()
         }
 
         [Test]
-        public void CanNestScopes_EfCore_Core_Normal()
+        public void CanNestScopes_EFCore_Core_Normal()
         {
-            using (var ambientScope = EfCoreScopeProvider.CreateScope())
+            using (var ambientScope = EFCoreScopeProvider.CreateScope())
             {
                 ambientScope.WriteLock(Constants.Locks.ContentTree);
 
@@ -203,13 +203,13 @@ public void CanNestScopes_Core_Core()
         }
 
         [Test]
-        public void CanNestScopes_EfCore_EfCore()
+        public void CanNestScopes_EFCore_EFCore()
         {
-            using (var ambientScope = EfCoreScopeProvider.CreateScope())
+            using (var ambientScope = EFCoreScopeProvider.CreateScope())
             {
                 ambientScope.WriteLock(Constants.Locks.ContentTree);
 
-                using (var inner = EfCoreScopeProvider.CreateScope())
+                using (var inner = EFCoreScopeProvider.CreateScope())
                 {
                     inner.WriteLock(Constants.Locks.ContentTree);
 
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/CachedDataTypeServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/CachedDataTypeServiceTests.cs
index e1746860878d..224621e03518 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/CachedDataTypeServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/CachedDataTypeServiceTests.cs
@@ -8,6 +8,7 @@
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Tests.Common.Testing;
 using Umbraco.Cms.Tests.Integration.Testing;
+using Umbraco.Cms.Core;
 
 namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
 
@@ -30,7 +31,7 @@ internal sealed class CachedDataTypeServiceTests : UmbracoIntegrationTest
     ///     with Count verification works.
     /// </summary>
     [Test]
-    public void DataTypeService_Can_Get_All()
+    public async Task DataTypeService_Can_Get_All()
     {
         IDataType dataType =
             new DataType(new LabelPropertyEditor(DataValueEditorFactory, IOHelper), ConfigurationEditorJsonSerializer)
@@ -38,13 +39,13 @@ public void DataTypeService_Can_Get_All()
                 Name = "Testing Textfield",
                 DatabaseType = ValueStorageType.Ntext
             };
-        DataTypeService.Save(dataType);
+        await DataTypeService.CreateAsync(dataType, Constants.Security.SuperUserKey);
 
         // Get all the first time (no cache)
-        var all = DataTypeService.GetAll();
+        var all = await DataTypeService.GetAllAsync();
 
         // Get all a second time (with cache)
-        all = DataTypeService.GetAll();
+        all = await DataTypeService.GetAllAsync();
 
         Assert.Pass();
     }
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentBlueprintEditingServiceTests.Move.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentBlueprintEditingServiceTests.Move.cs
index 240f280ad8ed..aa812433a737 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentBlueprintEditingServiceTests.Move.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentBlueprintEditingServiceTests.Move.cs
@@ -1,5 +1,6 @@
 using NUnit.Framework;
 using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
 
 namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
 
@@ -31,6 +32,9 @@ public async Task Can_Move_Blueprint_From_Root_To_A_Folder()
             Assert.AreEqual(1, result.Length);
             Assert.AreEqual(blueprintKey, result.First().Key);
         });
+
+        var auditLog = (await AuditService.GetItemsByEntityAsync(blueprint!.Id, 0, 1)).Items.First();
+        Assert.AreEqual(AuditType.Move, auditLog.AuditType);
     }
 
     [Test]
@@ -60,6 +64,9 @@ public async Task Can_Move_Blueprint_From_A_Folder_To_Root()
             Assert.AreEqual(1, result.Length);
             Assert.AreEqual(blueprintKey, result.First().Key);
         });
+
+        var auditLog = (await AuditService.GetItemsByEntityAsync(blueprint!.Id, 0, 1)).Items.First();
+        Assert.AreEqual(AuditType.Move, auditLog.AuditType);
     }
 
     [Test]
@@ -89,5 +96,8 @@ public async Task Can_Move_Blueprint_Between_Folders()
             Assert.AreEqual(1, result.Length);
             Assert.AreEqual(blueprintKey, result.First().Key);
         });
+
+        var auditLog = (await AuditService.GetItemsByEntityAsync(blueprint!.Id, 0, 1)).Items.First();
+        Assert.AreEqual(AuditType.Move, auditLog.AuditType);
     }
 }
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentBlueprintEditingServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentBlueprintEditingServiceTests.cs
index 57b59da68a47..96b65902205c 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentBlueprintEditingServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentBlueprintEditingServiceTests.cs
@@ -18,6 +18,8 @@ public partial class ContentBlueprintEditingServiceTests : ContentEditingService
 
     private IEntityService EntityService => GetRequiredService<IEntityService>();
 
+    private IAuditService AuditService => GetRequiredService<IAuditService>();
+
     private IJsonSerializer JsonSerializer => GetRequiredService<IJsonSerializer>();
 
     private async Task<IContent> CreateInvariantContentBlueprint()
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentEventsTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentEventsTests.cs
index 2957e3082232..c93970c51cec 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentEventsTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentEventsTests.cs
@@ -11,8 +11,8 @@
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Notifications;
 using Umbraco.Cms.Core.Persistence.Repositories;
+using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Sync;
-using Umbraco.Cms.Core.Web;
 using Umbraco.Cms.Infrastructure.Serialization;
 using Umbraco.Cms.Infrastructure.Sync;
 using Umbraco.Cms.Tests.Common.Attributes;
@@ -26,12 +26,10 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services
     [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
     internal sealed class ContentEventsTests : UmbracoIntegrationTestWithContent
     {
-        private CacheRefresherCollection CacheRefresherCollection => GetRequiredService<CacheRefresherCollection>();
-
-        private IUmbracoContextFactory UmbracoContextFactory => GetRequiredService<IUmbracoContextFactory>();
-
         private ILogger<ContentEventsTests> Logger => GetRequiredService<ILogger<ContentEventsTests>>();
 
+        private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
+
         #region Setup
 
         private class TestNotificationHandler :
@@ -177,17 +175,17 @@ protected override void CustomTestSetup(IUmbracoBuilder builder)
         }
 
         [SetUp]
-        public void SetUp()
+        public async Task SetUp()
         {
             _events = new List<EventInstance>();
 
             // prepare content type
             Template template = TemplateBuilder.CreateTextPageTemplate();
-            FileService.SaveTemplate(template);
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
             _contentType = ContentTypeBuilder.CreateSimpleContentType("whatever", "Whatever", defaultTemplateId: template.Id);
             _contentType.Key = Guid.NewGuid();
-            FileService.SaveTemplate(_contentType.DefaultTemplate);
+            await TemplateService.CreateAsync(_contentType.DefaultTemplate, Constants.Security.SuperUserKey);
             ContentTypeService.Save(_contentType);
         }
 
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceNotificationTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceNotificationTests.cs
index 8e4bf6ffef00..94a897c89867 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceNotificationTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceNotificationTests.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using System.Linq;
 using NUnit.Framework;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Configuration.Models;
@@ -26,12 +25,12 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
 internal sealed class ContentServiceNotificationTests : UmbracoIntegrationTest
 {
     [SetUp]
-    public void SetupTest()
+    public async Task SetupTest()
     {
         ContentRepositoryBase.ThrowOnWarning = true;
         _globalSettings = new GlobalSettings();
 
-        CreateTestData();
+        await CreateTestData();
     }
 
     [TearDown]
@@ -43,7 +42,7 @@ public void SetupTest()
 
     private ILanguageService LanguageService => GetRequiredService<ILanguageService>();
 
-    private IFileService FileService => GetRequiredService<IFileService>();
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
 
     private GlobalSettings _globalSettings;
     private IContentType _contentType;
@@ -57,10 +56,10 @@ protected override void CustomTestSetup(IUmbracoBuilder builder) => builder
         .AddNotificationHandler<ContentUnpublishedNotification, ContentNotificationHandler>()
         .AddNotificationHandler<ContentTreeChangeNotification, ContentNotificationHandler>();
 
-    private void CreateTestData()
+    private async Task CreateTestData()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template); // else, FK violation on contentType!
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey); // else, FK violation on contentType!
 
         _contentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id);
         ContentTypeService.Save(_contentType);
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServicePerformanceTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServicePerformanceTest.cs
index cc017cf2187c..1c44224ab82b 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServicePerformanceTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServicePerformanceTest.cs
@@ -1,9 +1,7 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using NUnit.Framework;
@@ -26,11 +24,11 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
 internal sealed class ContentServicePerformanceTest : UmbracoIntegrationTest
 {
     [SetUp]
-    public void SetUpData() => CreateTestData();
+    public async Task SetUpData() => await CreateTestDataAsync();
 
     private DocumentRepository DocumentRepository => (DocumentRepository)GetRequiredService<IDocumentRepository>();
 
-    private IFileService FileService => GetRequiredService<IFileService>();
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
 
     private IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
 
@@ -49,7 +47,7 @@ private static IProfilingLogger GetTestProfilingLogger()
 
     [Test]
     [LongRunning]
-    public void Retrieving_All_Content_In_Site()
+    public async Task Retrieving_All_Content_In_Site()
     {
         // NOTE: Doing this the old 1 by 1 way and based on the results of the ContentServicePerformanceTest.Retrieving_All_Content_In_Site
         // the old way takes 143795ms, the new above way takes:
@@ -63,7 +61,7 @@ public void Retrieving_All_Content_In_Site()
         // ... NOPE, made even more nice changes, it is now...
         // 4452ms !!!!!!!
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType1 = ContentTypeBuilder.CreateTextPageContentType("test1", "test1", template.Id);
         var contentType2 = ContentTypeBuilder.CreateTextPageContentType("test2", "test2", template.Id);
@@ -268,10 +266,10 @@ public void Getting_1000_Cached_Items()
         }
     }
 
-    public void CreateTestData()
+    public async Task CreateTestDataAsync()
     {
         var template = TemplateBuilder.CreateTextPageTemplate("defaultTemplate");
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         // Create and Save ContentType "textpage" -> ContentType.Id
         ContentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id);
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceTagsTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceTagsTests.cs
index 8af1713feff2..b9424397e930 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceTagsTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceTagsTests.cs
@@ -1,7 +1,6 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using System.Linq;
 using NUnit.Framework;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Models;
@@ -13,7 +12,6 @@
 using Umbraco.Cms.Tests.Common.Builders.Extensions;
 using Umbraco.Cms.Tests.Common.Testing;
 using Umbraco.Cms.Tests.Integration.Testing;
-using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
 
@@ -41,7 +39,7 @@ internal sealed class ContentServiceTagsTests : UmbracoIntegrationTest
 
     private ILanguageService LanguageService => GetRequiredService<ILanguageService>();
 
-    private IFileService FileService => GetRequiredService<IFileService>();
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
 
     private IJsonSerializer Serializer => GetRequiredService<IJsonSerializer>();
 
@@ -51,10 +49,10 @@ internal sealed class ContentServiceTagsTests : UmbracoIntegrationTest
     public PropertyEditorCollection PropertyEditorCollection => GetRequiredService<PropertyEditorCollection>();
 
     [Test]
-    public void TagsCanBeInvariant()
+    public async Task TagsCanBeInvariant()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -105,7 +103,7 @@ public async Task TagsCanBeVariant()
         await LanguageService.CreateAsync(language, Constants.Security.SuperUserKey); // en-US is already there
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -174,7 +172,7 @@ public async Task TagsCanBecomeVariant()
         var enId = (await LanguageService.GetAsync("en-US"))!.Id;
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -261,7 +259,7 @@ public async Task TagsCanBecomeInvariant()
         await LanguageService.CreateAsync(language, Constants.Security.SuperUserKey); // en-US is already there
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -334,7 +332,7 @@ public async Task TagsCanBecomeInvariant2()
         await LanguageService.CreateAsync(language, Constants.Security.SuperUserKey); // en-US is already there
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -404,7 +402,7 @@ public async Task TagsCanBecomeInvariantByPropertyType()
         await LanguageService.CreateAsync(language, Constants.Security.SuperUserKey); // en-US is already there
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -480,7 +478,7 @@ public async Task TagsCanBecomeInvariantByPropertyTypeAndBackToVariant()
         await LanguageService.CreateAsync(language, Constants.Security.SuperUserKey); // en-US is already there
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -522,10 +520,10 @@ public async Task TagsCanBecomeInvariantByPropertyTypeAndBackToVariant()
     }
 
     [Test]
-    public void TagsAreUpdatedWhenContentIsTrashedAndUnTrashed_One()
+    public async Task TagsAreUpdatedWhenContentIsTrashedAndUnTrashed_One()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -565,10 +563,10 @@ public void TagsAreUpdatedWhenContentIsTrashedAndUnTrashed_One()
     }
 
     [Test]
-    public void TagsAreUpdatedWhenContentIsTrashedAndUnTrashed_All()
+    public async Task TagsAreUpdatedWhenContentIsTrashedAndUnTrashed_All()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -610,10 +608,10 @@ public void TagsAreUpdatedWhenContentIsTrashedAndUnTrashed_All()
 
     [Test]
     [Ignore("https://github.com/umbraco/Umbraco-CMS/issues/3821 (U4-8442), will need to be fixed.")]
-    public void TagsAreUpdatedWhenContentIsTrashedAndUnTrashed_Tree()
+    public async Task TagsAreUpdatedWhenContentIsTrashedAndUnTrashed_Tree()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -698,10 +696,10 @@ public void TagsAreUpdatedWhenContentIsTrashedAndUnTrashed_Tree()
     }
 
     [Test]
-    public void TagsAreUpdatedWhenContentIsUnpublishedAndRePublished()
+    public async Task TagsAreUpdatedWhenContentIsUnpublishedAndRePublished()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -737,10 +735,10 @@ public void TagsAreUpdatedWhenContentIsUnpublishedAndRePublished()
 
     [Test]
     [Ignore("https://github.com/umbraco/Umbraco-CMS/issues/3821 (U4-8442), will need to be fixed.")]
-    public void TagsAreUpdatedWhenContentIsUnpublishedAndRePublished_Tree()
+    public async Task TagsAreUpdatedWhenContentIsUnpublishedAndRePublished_Tree()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -792,7 +790,7 @@ public void TagsAreUpdatedWhenContentIsUnpublishedAndRePublished_Tree()
     }
 
     [Test]
-    public void Create_Tag_Data_Bulk_Publish_Operation()
+    public async Task Create_Tag_Data_Bulk_Publish_Operation()
     {
         // Arrange
         // set configuration
@@ -806,7 +804,7 @@ public void Create_Tag_Data_Bulk_Publish_Operation()
         DataTypeService.Save(dataType);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -865,10 +863,10 @@ public void Create_Tag_Data_Bulk_Publish_Operation()
     }
 
     [Test]
-    public void Does_Not_Create_Tag_Data_For_Non_Published_Version()
+    public async Task Does_Not_Create_Tag_Data_For_Non_Published_Version()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         // create content type with a tag property
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
@@ -915,10 +913,10 @@ public void Does_Not_Create_Tag_Data_For_Non_Published_Version()
     }
 
     [Test]
-    public void Can_Replace_Tag_Data_To_Published_Content()
+    public async Task Can_Replace_Tag_Data_To_Published_Content()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         // Arrange
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
@@ -955,10 +953,10 @@ public void Can_Replace_Tag_Data_To_Published_Content()
     }
 
     [Test]
-    public void Can_Append_Tag_Data_To_Published_Content()
+    public async Task Can_Append_Tag_Data_To_Published_Content()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         // Arrange
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
@@ -1003,10 +1001,10 @@ public void Can_Append_Tag_Data_To_Published_Content()
     }
 
     [Test]
-    public void Can_Remove_Tag_Data_To_Published_Content()
+    public async Task Can_Remove_Tag_Data_To_Published_Content()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         // Arrange
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
@@ -1045,7 +1043,7 @@ public void Can_Remove_Tag_Data_To_Published_Content()
     }
 
     [Test]
-    public void Does_Not_Save_Multiple_Tags_As_One_When_CSV_Storage()
+    public async Task Does_Not_Save_Multiple_Tags_As_One_When_CSV_Storage()
     {
         // Arrange
         // set configuration
@@ -1059,7 +1057,7 @@ public void Does_Not_Save_Multiple_Tags_As_One_When_CSV_Storage()
         DataTypeService.Save(dataType);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
@@ -1091,7 +1089,7 @@ public void Does_Not_Save_Multiple_Tags_As_One_When_CSV_Storage()
     }
 
     [Test]
-    public void Can_Save_Tag_With_Comma_Separated_Values_As_One_When_JSON_Storage()
+    public async Task Can_Save_Tag_With_Comma_Separated_Values_As_One_When_JSON_Storage()
     {
         // Arrange
         // set configuration
@@ -1110,7 +1108,7 @@ public void Can_Save_Tag_With_Comma_Separated_Values_As_One_When_JSON_Storage()
         DataTypeService.Save(dataType);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(
             "umbMandatory",
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentVersionCleanupServiceTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentVersionCleanupServiceTest.cs
index 06f7afd27e92..1f6a4d2219e3 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentVersionCleanupServiceTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentVersionCleanupServiceTest.cs
@@ -1,10 +1,12 @@
 using System.Diagnostics;
+using Microsoft.Extensions.DependencyInjection;
 using NUnit.Framework;
-using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Services;
-using Umbraco.Cms.Infrastructure.Persistence.Dtos;
 using Umbraco.Cms.Tests.Common.Builders;
 using Umbraco.Cms.Tests.Common.Testing;
+using Umbraco.Cms.Tests.Integration.Attributes;
 using Umbraco.Cms.Tests.Integration.Testing;
 
 namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
@@ -13,7 +15,7 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
 internal class ContentVersionCleanupServiceTest : UmbracoIntegrationTest
 {
-    public IFileService FileService => GetRequiredService<IFileService>();
+    public ITemplateService TemplateService => GetRequiredService<ITemplateService>();
 
     public IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
 
@@ -23,10 +25,9 @@ internal class ContentVersionCleanupServiceTest : UmbracoIntegrationTest
 
     /// <remarks>
     ///     This is covered by the unit tests, but nice to know it deletes on infra.
-    ///     And proves implementation is compatible with SQL CE.
     /// </remarks>
     [Test]
-    public void PerformContentVersionCleanup_WithNoKeepPeriods_DeletesEverythingExceptActive()
+    public async Task PerformContentVersionCleanup_WithNoKeepPeriods_DeletesEverythingExceptActive()
     {
         // For reference, Our currently has
         // 5000 Documents
@@ -34,7 +35,7 @@ public void PerformContentVersionCleanup_WithNoKeepPeriods_DeletesEverythingExce
         // With 11M Property data
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var contentTypeA =
             ContentTypeBuilder.CreateSimpleContentType("contentTypeA", "contentTypeA", defaultTemplateId: template.Id);
@@ -44,15 +45,15 @@ public void PerformContentVersionCleanup_WithNoKeepPeriods_DeletesEverythingExce
         contentTypeA.HistoryCleanup.KeepAllVersionsNewerThanDays = 0;
         contentTypeA.HistoryCleanup.KeepLatestVersionPerDayForDays = 0;
 
-        ContentTypeService.Save(contentTypeA);
+        await ContentTypeService.CreateAsync(contentTypeA, Constants.Security.SuperUserKey);
 
         var content = ContentBuilder.CreateSimpleContent(contentTypeA);
         ContentService.Save(content);
-        ContentService.Publish(content, Array.Empty<string>());
+        ContentService.Publish(content, []);
 
         for (var i = 0; i < 10; i++)
         {
-            ContentService.Publish(content, Array.Empty<string>());
+            ContentService.Publish(content, []);
         }
 
         var before = GetReport();
@@ -72,46 +73,297 @@ public void PerformContentVersionCleanup_WithNoKeepPeriods_DeletesEverythingExce
         });
     }
 
-    private Report GetReport()
+    [Test]
+    public async Task PerformContentVersionCleanup_WithKeepAllNewerThanDays_RetainsRecentVersions()
     {
+        var template = TemplateBuilder.CreateTextPageTemplate();
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
+
+        var contentType =
+            ContentTypeBuilder.CreateSimpleContentType("contentTypeA", "contentTypeA", defaultTemplateId: template.Id);
+
+        contentType.HistoryCleanup.PreventCleanup = false;
+        contentType.HistoryCleanup.KeepAllVersionsNewerThanDays = 7;
+        contentType.HistoryCleanup.KeepLatestVersionPerDayForDays = 0;
+
+        await ContentTypeService.CreateAsync(contentType, Constants.Security.SuperUserKey);
+
+        var content = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content);
+        ContentService.Publish(content, []);
+
+        for (var i = 0; i < 5; i++)
+        {
+            ContentService.Publish(content, []);
+        }
+
+        // Total: 7 versions (1 initial save + 6 publishes). Current draft + current published = 2 active.
+        // 5 historic versions.
+        var before = GetReport();
+        Assert.AreEqual(7, before.ContentVersions);
+
+        // Backdate 3 of the historic versions to 10 days ago so they exceed the 7-day keep window.
         using (var scope = ScopeProvider.CreateScope(autoComplete: true))
         {
-            // SQL CE is fun!
-            var contentVersions =
-                ScopeAccessor.AmbientScope.Database.Single<int>(@"select count(1) from umbracoContentVersion");
-            var documentVersions =
-                ScopeAccessor.AmbientScope.Database.Single<int>(@"select count(1) from umbracoDocumentVersion");
-            var propertyData =
-                ScopeAccessor.AmbientScope.Database.Single<int>(@"select count(1) from umbracoPropertyData");
-
-            return new Report
-            {
-                ContentVersions = contentVersions,
-                DocumentVersions = documentVersions,
-                PropertyData = propertyData
-            };
+            var db = ScopeAccessor.AmbientScope!.Database;
+            var syntax = db.SqlContext.SqlSyntax;
+
+            var umbracoContentVersion = syntax.GetQuotedTableName("umbracoContentVersion");
+            var versionDate = syntax.GetQuotedColumnName("versionDate");
+            db.Execute(
+                $"UPDATE {umbracoContentVersion} SET {versionDate} = @0 WHERE id IN (1, 2, 3)",
+                DateTime.UtcNow.AddDays(-10));
         }
+
+        ContentVersionService.PerformContentVersionCleanup(DateTime.UtcNow);
+
+        var after = GetReport();
+
+        Assert.Multiple(() =>
+        {
+            // 3 backdated historic versions should be deleted. 2 active + 2 recent historic remain = 4.
+            Assert.AreEqual(4, after.ContentVersions);
+            Assert.AreEqual(4, after.DocumentVersions);
+        });
     }
 
-    private void InsertCleanupPolicy(
-        IContentType contentType,
-        int daysToKeepAll,
-        int daysToRollupAll,
-        bool preventCleanup = false)
+    [Test]
+    public async Task PerformContentVersionCleanup_WithKeepLatestPerDay_RetainsOnePerDay()
     {
+        var template = TemplateBuilder.CreateTextPageTemplate();
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
+
+        var contentType =
+            ContentTypeBuilder.CreateSimpleContentType("contentTypeA", "contentTypeA", defaultTemplateId: template.Id);
+
+        contentType.HistoryCleanup.PreventCleanup = false;
+        contentType.HistoryCleanup.KeepAllVersionsNewerThanDays = 0;
+        contentType.HistoryCleanup.KeepLatestVersionPerDayForDays = 90;
+
+        await ContentTypeService.CreateAsync(contentType, Constants.Security.SuperUserKey);
+
+        var content = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content);
+        ContentService.Publish(content, []);
+
+        // Create 6 more publishes (total 8 versions = 1 save + 7 publishes)
+        for (var i = 0; i < 6; i++)
+        {
+            ContentService.Publish(content, []);
+        }
+
+        var before = GetReport();
+        Assert.AreEqual(8, before.ContentVersions);
+
+        // Backdate versions into 3 "days":
+        // Day 1 (10 days ago): versions 1, 2, 3 — should keep only version 3 (newest)
+        // Day 2 (5 days ago): versions 4, 5 — should keep only version 5 (newest)
+        // Day 3 (today): version 6 is historic, 7 & 8 are active (draft + published)
+        //   Version 6 is the only historic version today — should be kept as latest for today
         using (var scope = ScopeProvider.CreateScope(autoComplete: true))
         {
-            var entity = new ContentVersionCleanupPolicyDto
+            var db = ScopeAccessor.AmbientScope!.Database;
+            var syntax = db.SqlContext.SqlSyntax;
+            var umbracoContentVersion = syntax.GetQuotedTableName("umbracoContentVersion");
+            var versionDate = syntax.GetQuotedColumnName("versionDate");
+            var tenDaysAgo = DateTime.UtcNow.AddDays(-10);
+            var fiveDaysAgo = DateTime.UtcNow.AddDays(-5);
+            db.Execute($"UPDATE {umbracoContentVersion} SET {versionDate} = @0 WHERE id IN (1, 2, 3)", tenDaysAgo);
+            db.Execute($"UPDATE {umbracoContentVersion} SET {versionDate} = @0 WHERE id IN (4, 5)", fiveDaysAgo);
+        }
+
+        ContentVersionService.PerformContentVersionCleanup(DateTime.UtcNow);
+
+        var after = GetReport();
+
+        Assert.Multiple(() =>
+        {
+            // Deleted: versions 1, 2 (day 1 non-latest) + version 4 (day 2 non-latest) = 3 deleted
+            // Remaining: version 3 (day 1 latest) + version 5 (day 2 latest) + version 6 (today latest)
+            //           + version 7 (current draft) + version 8 (current published) = 5
+            Assert.AreEqual(5, after.ContentVersions);
+            Assert.AreEqual(5, after.DocumentVersions);
+        });
+    }
+
+    [Test]
+    public async Task PerformContentVersionCleanup_WithContentTypeOverride_RespectsPreventCleanup()
+    {
+        var template = TemplateBuilder.CreateTextPageTemplate();
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
+
+        var contentTypeA =
+            ContentTypeBuilder.CreateSimpleContentType("contentTypeA", "contentTypeA", defaultTemplateId: template.Id);
+        contentTypeA.HistoryCleanup.PreventCleanup = false;
+        contentTypeA.HistoryCleanup.KeepAllVersionsNewerThanDays = 0;
+        contentTypeA.HistoryCleanup.KeepLatestVersionPerDayForDays = 0;
+        await ContentTypeService.CreateAsync(contentTypeA, Constants.Security.SuperUserKey);
+
+        var contentTypeB =
+            ContentTypeBuilder.CreateSimpleContentType("contentTypeB", "contentTypeB", defaultTemplateId: template.Id);
+
+        // Set preventCleanup directly on the content type — this creates the override policy row automatically.
+        contentTypeB.HistoryCleanup.PreventCleanup = true;
+        contentTypeB.HistoryCleanup.KeepAllVersionsNewerThanDays = 0;
+        contentTypeB.HistoryCleanup.KeepLatestVersionPerDayForDays = 0;
+        await ContentTypeService.CreateAsync(contentTypeB, Constants.Security.SuperUserKey);
+
+        var contentA = ContentBuilder.CreateSimpleContent(contentTypeA);
+        ContentService.Save(contentA);
+        ContentService.Publish(contentA, []);
+        ContentService.Publish(contentA, []);
+
+        var contentB = ContentBuilder.CreateSimpleContent(contentTypeB);
+        ContentService.Save(contentB);
+        ContentService.Publish(contentB, []);
+        ContentService.Publish(contentB, []);
+
+        var before = GetReport();
+        Assert.Greater(before.ContentVersions, 4);
+
+        ContentVersionService.PerformContentVersionCleanup(DateTime.UtcNow.AddHours(1));
+
+        var after = GetReport();
+
+        // Verify contentTypeB versions were preserved by checking the DB directly
+        using (var scope = ScopeProvider.CreateScope(autoComplete: true))
+        {
+            var db = ScopeAccessor.AmbientScope!.Database;
+            var syntax = db.SqlContext.SqlSyntax;
+
+            var umbracoContentVersion = syntax.GetQuotedTableName("umbracoContentVersion");
+            var umbracoContent = syntax.GetQuotedTableName("umbracoContent");
+            var nodeId = syntax.GetQuotedColumnName("nodeId");
+            var contentTypeId = syntax.GetQuotedColumnName("contentTypeId");
+            var contentAVersions = db.Single<int>(
+                $"SELECT count(1) FROM {umbracoContentVersion} cv INNER JOIN {umbracoContent} c ON cv.{nodeId} = c.{nodeId} WHERE c.{contentTypeId} = @0",
+                contentTypeA.Id);
+            var contentBVersions = db.Single<int>(
+                $"SELECT count(1) FROM {umbracoContentVersion} cv INNER JOIN {umbracoContent} c ON cv.{nodeId} = c.{nodeId} WHERE c.{contentTypeId} = @0",
+                contentTypeB.Id);
+
+            Assert.Multiple(() =>
             {
-                ContentTypeId = contentType.Id,
-                KeepAllVersionsNewerThanDays = daysToKeepAll,
-                KeepLatestVersionPerDayForDays = daysToRollupAll,
-                PreventCleanup = preventCleanup,
-                Updated = DateTime.Today
-            };
-
-            ScopeAccessor.AmbientScope.Database.Insert(entity);
+                // ContentTypeA: only active versions remain (current draft + current published = 2)
+                Assert.AreEqual(2, contentAVersions);
+                // ContentTypeB: all versions preserved (preventCleanup override)
+                Assert.Greater(contentBVersions, 2);
+            });
+        }
+    }
+
+    [Test]
+    public async Task PerformContentVersionCleanup_MultipleCalls_IsIdempotent()
+    {
+        var template = TemplateBuilder.CreateTextPageTemplate();
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
+
+        var contentType =
+            ContentTypeBuilder.CreateSimpleContentType("contentTypeA", "contentTypeA", defaultTemplateId: template.Id);
+        contentType.HistoryCleanup.PreventCleanup = false;
+        contentType.HistoryCleanup.KeepAllVersionsNewerThanDays = 0;
+        contentType.HistoryCleanup.KeepLatestVersionPerDayForDays = 0;
+        await ContentTypeService.CreateAsync(contentType, Constants.Security.SuperUserKey);
+
+        var content = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content);
+        ContentService.Publish(content, []);
+
+        for (var i = 0; i < 5; i++)
+        {
+            ContentService.Publish(content, []);
+        }
+
+        // First cleanup run
+        var firstResult = ContentVersionService.PerformContentVersionCleanup(DateTime.UtcNow.AddHours(1));
+        Assert.Greater(firstResult.Count, 0, "First run should delete some versions");
+
+        var afterFirst = GetReport();
+
+        // Second cleanup run — should have nothing to do
+        var secondResult = ContentVersionService.PerformContentVersionCleanup(DateTime.UtcNow.AddHours(1));
+        Assert.AreEqual(0, secondResult.Count, "Second run should delete nothing");
+
+        var afterSecond = GetReport();
+
+        Assert.Multiple(() =>
+        {
+            Assert.AreEqual(afterFirst.ContentVersions, afterSecond.ContentVersions);
+            Assert.AreEqual(afterFirst.DocumentVersions, afterSecond.DocumentVersions);
+            Assert.AreEqual(afterFirst.PropertyData, afterSecond.PropertyData);
+        });
+    }
+
+    public static void ConfigureLowMaxVersionsPerRun(IUmbracoBuilder builder)
+    {
+        builder.Services.Configure<ContentSettings>(settings =>
+            settings.ContentVersionCleanupPolicy.MaxVersionsToDeletePerRun = 3);
+    }
+
+    [Test]
+    [ConfigureBuilder(ActionName = nameof(ConfigureLowMaxVersionsPerRun))]
+    public async Task PerformContentVersionCleanup_WithMaxVersionsPerRunCap_DeletesOnlyUpToCap()
+    {
+        var template = TemplateBuilder.CreateTextPageTemplate();
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
+
+        var contentType = ContentTypeBuilder.CreateSimpleContentType("contentTypeA", "contentTypeA", defaultTemplateId: template.Id);
+        contentType.HistoryCleanup.PreventCleanup = false;
+        contentType.HistoryCleanup.KeepAllVersionsNewerThanDays = 0;
+        contentType.HistoryCleanup.KeepLatestVersionPerDayForDays = 0;
+        await ContentTypeService.CreateAsync(contentType, Constants.Security.SuperUserKey);
+
+        var content = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content);
+        ContentService.Publish(content, []);
+
+        for (var i = 0; i < 8; i++)
+        {
+            ContentService.Publish(content, []);
         }
+
+        // 10 versions total: 8 historic + current draft + current published.
+        var before = GetReport();
+        Assert.AreEqual(10, before.ContentVersions);
+
+        // First run: MaxVersionsToDeletePerRun = 3, so only 3 historic versions should be deleted.
+        var firstResult = ContentVersionService.PerformContentVersionCleanup(DateTime.UtcNow.AddHours(1));
+        Assert.AreEqual(3, firstResult.Count, "First run should delete exactly 3 (the per-run cap)");
+
+        var afterFirst = GetReport();
+        Assert.AreEqual(7, afterFirst.ContentVersions);
+
+        // Second run: another 3 deleted.
+        var secondResult = ContentVersionService.PerformContentVersionCleanup(DateTime.UtcNow.AddHours(1));
+        Assert.AreEqual(3, secondResult.Count, "Second run should delete another 3");
+
+        var afterSecond = GetReport();
+        Assert.AreEqual(4, afterSecond.ContentVersions);
+
+        // Third run: only 2 historic remain, so fewer than cap deleted.
+        var thirdResult = ContentVersionService.PerformContentVersionCleanup(DateTime.UtcNow.AddHours(1));
+        Assert.AreEqual(2, thirdResult.Count, "Third run should delete remaining 2");
+
+        var afterThird = GetReport();
+        Assert.AreEqual(2, afterThird.ContentVersions); // Only current draft + current published remain.
+    }
+
+    private Report GetReport()
+    {
+        using var scope = ScopeProvider.CreateScope(autoComplete: true);
+
+        var database = ScopeAccessor.AmbientScope.Database;
+        var syntax = database.SqlContext.SqlSyntax;
+        var contentVersions = database.Single<int>($"select count(1) from {syntax.GetQuotedTableName("umbracoContentVersion")}");
+        var documentVersions = database.Single<int>($"select count(1) from {syntax.GetQuotedTableName("umbracoDocumentVersion")}");
+        var propertyData = database.Single<int>($"select count(1) from {syntax.GetQuotedTableName("umbracoPropertyData")}");
+
+        return new Report
+        {
+            ContentVersions = contentVersions,
+            DocumentVersions = documentVersions,
+            PropertyData = propertyData,
+        };
     }
 
     private class Report
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/EntityServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/EntityServiceTests.cs
index ce9c39299d0b..a9e6ed9f8f16 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/EntityServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/EntityServiceTests.cs
@@ -55,7 +55,7 @@ public async Task SetupTestData()
 
     private IMediaService MediaService => GetRequiredService<IMediaService>();
 
-    private IFileService FileService => GetRequiredService<IFileService>();
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
 
     private IContentTypeContainerService ContentTypeContainerService => GetRequiredService<IContentTypeContainerService>();
 
@@ -692,11 +692,11 @@ public void EntityService_Can_Get_Child_Content_By_ParentId_And_UmbracoObjectTyp
     }
 
     [Test]
-    public void EntityService_Can_Get_Content_By_UmbracoObjectType_With_Variant_Names()
+    public async Task EntityService_Can_Get_Content_By_UmbracoObjectType_With_Variant_Names()
     {
         var alias = "test" + Guid.NewGuid();
         var template = TemplateBuilder.CreateTextPageTemplate(alias);
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType = ContentTypeBuilder.CreateSimpleContentType("test2", "Test2", defaultTemplateId: template.Id);
         contentType.Variations = ContentVariation.Culture;
         ContentTypeService.Save(contentType);
@@ -716,10 +716,10 @@ public void EntityService_Can_Get_Content_By_UmbracoObjectType_With_Variant_Name
     }
 
     [Test]
-    public void EntityService_Can_Get_Child_Content_By_ParentId_And_UmbracoObjectType_With_Variant_Names()
+    public async Task EntityService_Can_Get_Child_Content_By_ParentId_And_UmbracoObjectType_With_Variant_Names()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType = ContentTypeBuilder.CreateSimpleContentType("test1", "Test1", defaultTemplateId: template.Id);
         contentType.Variations = ContentVariation.Culture;
         ContentTypeService.Save(contentType);
@@ -1201,7 +1201,7 @@ public async Task CreateTestData()
             _isSetup = true;
 
             var template = TemplateBuilder.CreateTextPageTemplate("defaultTemplate");
-            FileService.SaveTemplate(template); // else, FK violation on contentType!
+            await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey); // else, FK violation on contentType!
 
             // Create and Save ContentType "umbTextpage" -> _contentType.Id
             _contentType =
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/EntityXmlSerializerTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/EntityXmlSerializerTests.cs
index 8e6f601f29f3..de3be316fbba 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/EntityXmlSerializerTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/EntityXmlSerializerTests.cs
@@ -1,25 +1,17 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using System.Collections.Generic;
-using System.Diagnostics;
 using System.Xml.Linq;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
-using Microsoft.Extensions.Options;
 using Moq;
 using NUnit.Framework;
 using Umbraco.Cms.Core;
-using Umbraco.Cms.Core.Cache.PropertyEditors;
 using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.IO;
-using Umbraco.Cms.Core.Media;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.ContentEditing;
-using Umbraco.Cms.Core.Persistence.Repositories;
 using Umbraco.Cms.Core.PropertyEditors;
-using Umbraco.Cms.Core.Serialization;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Strings;
 using Umbraco.Cms.Tests.Common.Builders;
@@ -41,8 +33,7 @@ internal sealed class EntityXmlSerializerTests : UmbracoIntegrationTest
     private IMediaTypeService MediaTypeService => GetRequiredService<IMediaTypeService>();
     private IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
     private IDataValueEditorFactory DataValueEditorFactory => GetRequiredService<IDataValueEditorFactory>();
-    private ILocalizedTextService TextService => GetRequiredService<ILocalizedTextService>();
-    private IFileService FileService => GetRequiredService<IFileService>();
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
 
     [Test]
     public async Task Can_Export_DictionaryItems()
@@ -90,11 +81,11 @@ public async Task Can_Export_Languages()
     }
 
     [Test]
-    public void Can_Generate_Xml_Representation_Of_Content()
+    public async Task Can_Generate_Xml_Representation_Of_Content()
     {
         // Arrange
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template); // else, FK violation on contentType!
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey); // else, FK violation on contentType!
         var contentType = ContentTypeBuilder.CreateTextPageContentType(
             defaultTemplateId: template.Id);
         ContentTypeService.Save(contentType);
@@ -213,11 +204,11 @@ public void Can_Generate_Xml_Representation_Of_Media()
     }
 
     [Test]
-    public void Serialize_ForContentTypeWithHistoryCleanupPolicy_OutputsSerializedHistoryCleanupPolicy()
+    public async Task Serialize_ForContentTypeWithHistoryCleanupPolicy_OutputsSerializedHistoryCleanupPolicy()
     {
         // Arrange
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template); // else, FK violation on contentType!
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey); // else, FK violation on contentType!
 
         var contentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id);
 
@@ -246,11 +237,11 @@ public void Serialize_ForContentTypeWithHistoryCleanupPolicy_OutputsSerializedHi
     }
 
     [Test]
-    public void Serialize_ForContentTypeWithNullHistoryCleanupPolicy_DoesNotOutputSerializedDefaultPolicy()
+    public async Task Serialize_ForContentTypeWithNullHistoryCleanupPolicy_DoesNotOutputSerializedDefaultPolicy()
     {
         // Arrange
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template); // else, FK violation on contentType!
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey); // else, FK violation on contentType!
 
         var contentType = ContentTypeBuilder.CreateTextPageContentType(defaultTemplateId: template.Id);
 
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ExternalLoginServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ExternalLoginServiceTests.cs
index 3b47fab6434d..5f23c6aec4d4 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ExternalLoginServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ExternalLoginServiceTests.cs
@@ -295,6 +295,7 @@ public async Task Concurrent_Save_Same_Login_Should_Not_Throw_Duplicate_Key_Exce
         UserService.Save(user);
 
         const int NumberOfConcurrentOperations = 10;
+        const int MaxDeadlockRetries = 3;
         var exceptions = new ConcurrentBag<Exception>();
         var providerKey = Guid.NewGuid().ToString("N");
 
@@ -313,14 +314,24 @@ public async Task Concurrent_Save_Same_Login_Should_Not_Throw_Duplicate_Key_Exce
                 tasks.Add(Task.Run(() =>
                 {
                     barrier.SignalAndWait();
-                    try
+                    for (var attempt = 0; attempt <= MaxDeadlockRetries; attempt++)
                     {
-                        var login = new ExternalLogin("TestProvider", providerKey);
-                        ExternalLoginService.Save(user.Key, [login]);
-                    }
-                    catch (Exception ex)
-                    {
-                        exceptions.Add(ex);
+                        try
+                        {
+                            var login = new ExternalLogin("TestProvider", providerKey);
+                            ExternalLoginService.Save(user.Key, [login]);
+                            return; // Success
+                        }
+                        catch (Exception ex) when (IsDeadlockException(ex) && attempt < MaxDeadlockRetries)
+                        {
+                            // SQL Server recommends retrying deadlocked transactions.
+                            Thread.Sleep(50 * (attempt + 1));
+                        }
+                        catch (Exception ex)
+                        {
+                            exceptions.Add(ex);
+                            return;
+                        }
                     }
                 }));
             }
@@ -332,9 +343,13 @@ public async Task Concurrent_Save_Same_Login_Should_Not_Throw_Duplicate_Key_Exce
         // Assert
         var exceptionDetails = exceptions.Select(e =>
             $"Type: {e.GetType().FullName}, Message: {e.Message}, Inner: {e.InnerException?.GetType().FullName}: {e.InnerException?.Message}");
-        Assert.IsEmpty(exceptions, $"Expected no duplicate key exceptions but got {exceptions.Count}:\n{string.Join("\n", exceptionDetails)}");
+        Assert.IsEmpty(exceptions, $"Expected no exceptions but got {exceptions.Count}:\n{string.Join("\n", exceptionDetails)}");
 
         var logins = ExternalLoginService.GetExternalLogins(user.Key).ToList();
         Assert.AreEqual(1, logins.Count, "Should have exactly one login");
     }
+
+    private static bool IsDeadlockException(Exception ex) =>
+        ex is Microsoft.Data.SqlClient.SqlException sqlEx && sqlEx.Number == 1205
+        || (ex.InnerException is Microsoft.Data.SqlClient.SqlException innerSqlEx && innerSqlEx.Number == 1205);
 }
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/FileServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/FileServiceTests.cs
deleted file mode 100644
index 74d1c27fb35c..000000000000
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/FileServiceTests.cs
+++ /dev/null
@@ -1,135 +0,0 @@
-// Copyright (c) Umbraco.
-// See LICENSE for more details.
-
-using System.Linq;
-using NUnit.Framework;
-using Umbraco.Cms.Core.IO;
-using Umbraco.Cms.Core.Services;
-using Umbraco.Cms.Tests.Common.Testing;
-using Umbraco.Cms.Tests.Integration.Testing;
-
-namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
-
-[TestFixture]
-[UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
-internal sealed class FileServiceTests : UmbracoIntegrationTest
-{
-    private IFileService FileService => GetRequiredService<IFileService>();
-
-    [SetUp]
-    public void SetUp()
-    {
-        var fileSystems = GetRequiredService<FileSystems>();
-        var viewFileSystem = fileSystems.MvcViewsFileSystem!;
-        foreach (var file in viewFileSystem.GetFiles(string.Empty).ToArray())
-        {
-            viewFileSystem.DeleteFile(file);
-        }
-    }
-
-    [Test]
-    public void Create_Template_Then_Assign_Child()
-    {
-        var child = FileService.CreateTemplateWithIdentity("Child", "child", "test");
-        var parent = FileService.CreateTemplateWithIdentity("Parent", "parent", "test");
-
-        child.Content = "Layout = \"Parent.cshtml\";";
-        FileService.SaveTemplate(child);
-
-        child = FileService.GetTemplate(child.Id);
-
-        Assert.AreEqual(parent.Alias, child.MasterTemplateAlias);
-    }
-
-    [Test]
-    public void Create_Template_With_Child_Then_Unassign()
-    {
-        var parent = FileService.CreateTemplateWithIdentity("Parent", "parent", "test");
-        var child = FileService.CreateTemplateWithIdentity("Child", "child", "Layout = \"Parent.cshtml\";");
-
-        child = FileService.GetTemplate(child.Id);
-        Assert.NotNull(child);
-        Assert.AreEqual("parent", child.MasterTemplateAlias);
-
-        child.Content = "test";
-        FileService.SaveTemplate(child);
-
-        child = FileService.GetTemplate(child.Id);
-        Assert.NotNull(child);
-        Assert.AreEqual(null, child.MasterTemplateAlias);
-    }
-
-    [Test]
-    public void Create_Template_With_Child_Then_Reassign()
-    {
-        var parent = FileService.CreateTemplateWithIdentity("Parent", "parent", "test");
-        var parent2 = FileService.CreateTemplateWithIdentity("Parent2", "parent2", "test");
-        var child = FileService.CreateTemplateWithIdentity("Child", "child", "Layout = \"Parent.cshtml\";");
-
-        child = FileService.GetTemplate(child.Id);
-        Assert.NotNull(child);
-        Assert.AreEqual("parent", child.MasterTemplateAlias);
-
-        child.Content = "Layout = \"Parent2.cshtml\";";
-        FileService.SaveTemplate(child);
-
-        child = FileService.GetTemplate(child.Id);
-        Assert.NotNull(child);
-        Assert.AreEqual("parent2", child.MasterTemplateAlias);
-    }
-
-    [Test]
-    public void Child_Template_Paths_Are_Updated_When_Reassigning_Master()
-    {
-        var parent = FileService.CreateTemplateWithIdentity("Parent", "parent", "test");
-        var parent2 = FileService.CreateTemplateWithIdentity("Parent2", "parent2", "test");
-        var child = FileService.CreateTemplateWithIdentity("Child", "child", "Layout = \"Parent.cshtml\";");
-        var childOfChild1 = FileService.CreateTemplateWithIdentity("Child1", "child1", "Layout = \"Child.cshtml\";");
-        var childOfChild2 = FileService.CreateTemplateWithIdentity("Child2", "child2", "Layout = \"Child.cshtml\";");
-
-        Assert.AreEqual($"child", childOfChild1.MasterTemplateAlias);
-        Assert.AreEqual($"{parent.Path},{child.Id},{childOfChild1.Id}", childOfChild1.Path);
-        Assert.AreEqual($"child", childOfChild2.MasterTemplateAlias);
-        Assert.AreEqual($"{parent.Path},{child.Id},{childOfChild2.Id}", childOfChild2.Path);
-
-        child.Content = "Layout = \"Parent2.cshtml\";";
-        FileService.SaveTemplate(child);
-
-        childOfChild1 = FileService.GetTemplate(childOfChild1.Id);
-        Assert.NotNull(childOfChild1);
-
-        childOfChild2 = FileService.GetTemplate(childOfChild2.Id);
-        Assert.NotNull(childOfChild2);
-
-        Assert.AreEqual($"child", childOfChild1.MasterTemplateAlias);
-        Assert.AreEqual($"{parent2.Path},{child.Id},{childOfChild1.Id}", childOfChild1.Path);
-        Assert.AreEqual($"child", childOfChild2.MasterTemplateAlias);
-        Assert.AreEqual($"{parent2.Path},{child.Id},{childOfChild2.Id}", childOfChild2.Path);
-    }
-
-    [Test]
-    public void Can_Query_Template_Children()
-    {
-        var parent = FileService.CreateTemplateWithIdentity("Parent", "parent", "test");
-        var child1 = FileService.CreateTemplateWithIdentity("Child1", "child1", "Layout = \"Parent.cshtml\";");
-        var child2 = FileService.CreateTemplateWithIdentity("Child2", "child2", "Layout = \"Parent.cshtml\";");
-
-        var children = FileService.GetTemplates(parent.Id).Select(x => x.Id).ToArray();
-
-        Assert.IsTrue(children.Contains(child1.Id));
-        Assert.IsTrue(children.Contains(child2.Id));
-    }
-
-    [Test]
-    public void Create_Template_With_Custom_Alias()
-    {
-        var template = FileService.CreateTemplateWithIdentity("Test template", "customTemplateAlias", "test");
-
-        FileService.SaveTemplate(template);
-
-        template = FileService.GetTemplate(template.Id);
-
-        Assert.AreEqual("Test template", template.Name);
-        Assert.AreEqual("customTemplateAlias", template.Alias);
-    }
-}
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/LocalizationServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/LocalizationServiceTests.cs
index 12ac27c6522d..204a16e8a794 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/LocalizationServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/LocalizationServiceTests.cs
@@ -24,6 +24,8 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
 internal sealed class LocalizationServiceTests : UmbracoIntegrationTest
 {
+    private ILanguageService LanguageService => GetRequiredService<ILanguageService>();
+
     [SetUp]
     public void SetUp() => CreateTestData();
 
@@ -36,22 +38,6 @@ internal sealed class LocalizationServiceTests : UmbracoIntegrationTest
 
     private ILocalizationService LocalizationService => GetRequiredService<ILocalizationService>();
 
-    [Test]
-    public void Can_Get_Root_Dictionary_Items()
-    {
-        var rootItems = LocalizationService.GetRootDictionaryItems();
-
-        Assert.NotNull(rootItems);
-        Assert.IsTrue(rootItems.Any());
-    }
-
-    [Test]
-    public void Can_Determint_If_DictionaryItem_Exists()
-    {
-        var exists = LocalizationService.DictionaryItemExists("Parent");
-        Assert.IsTrue(exists);
-    }
-
     [Test]
     public void Can_Get_All_Languages()
     {
@@ -81,15 +67,6 @@ public void Can_Get_Dictionary_Item_By_Guid_Id()
         Assert.NotNull(childItem);
     }
 
-    [Test]
-    public void Can_Get_Dictionary_Items_By_Guid_Ids()
-    {
-        var items = LocalizationService.GetDictionaryItemsByIds(_parentItemGuidId, _childItemGuidId);
-        Assert.AreEqual(2, items.Count());
-        Assert.NotNull(items.FirstOrDefault(i => i.Key == _parentItemGuidId));
-        Assert.NotNull(items.FirstOrDefault(i => i.Key == _childItemGuidId));
-    }
-
     [Test]
     public void Can_Get_Dictionary_Item_By_Key()
     {
@@ -100,15 +77,6 @@ public void Can_Get_Dictionary_Item_By_Key()
         Assert.NotNull(childItem);
     }
 
-    [Test]
-    public void Can_Get_Dictionary_Items_By_Keys()
-    {
-        var items = LocalizationService.GetDictionaryItemsByKeys("Parent", "Child");
-        Assert.AreEqual(2, items.Count());
-        Assert.NotNull(items.FirstOrDefault(i => i.ItemKey == "Parent"));
-        Assert.NotNull(items.FirstOrDefault(i => i.ItemKey == "Child"));
-    }
-
     [Test]
     public void Can_Get_Dictionary_Item_Children()
     {
@@ -123,54 +91,6 @@ public void Can_Get_Dictionary_Item_Children()
         }
     }
 
-    [Test]
-    public void Can_Get_Dictionary_Item_Descendants()
-    {
-        using (var scope = ScopeProvider.CreateScope())
-        {
-            var en = LocalizationService.GetLanguageById(_englishLangId);
-            var dk = LocalizationService.GetLanguageById(_danishLangId);
-
-            var currParentId = _childItemGuidId;
-            for (var i = 0; i < 25; i++)
-            {
-                // Create 2 per level
-                var desc1 = new DictionaryItem(currParentId, "D1" + i)
-                {
-                    Translations = new List<IDictionaryTranslation>
-                    {
-                        new DictionaryTranslation(en, "ChildValue1 " + i),
-                        new DictionaryTranslation(dk, "BørnVærdi1 " + i)
-                    }
-                };
-                var desc2 = new DictionaryItem(currParentId, "D2" + i)
-                {
-                    Translations = new List<IDictionaryTranslation>
-                    {
-                        new DictionaryTranslation(en, "ChildValue2 " + i),
-                        new DictionaryTranslation(dk, "BørnVærdi2 " + i)
-                    }
-                };
-                LocalizationService.Save(desc1);
-                LocalizationService.Save(desc2);
-
-                currParentId = desc1.Key;
-            }
-
-            ScopeAccessor.AmbientScope.Database.AsUmbracoDatabase().EnableSqlTrace = true;
-            ScopeAccessor.AmbientScope.Database.AsUmbracoDatabase().EnableSqlCount = true;
-
-            var items = LocalizationService.GetDictionaryItemDescendants(_parentItemGuidId).ToArray();
-
-            Debug.WriteLine("SQL CALLS: " + ScopeAccessor.AmbientScope.Database.AsUmbracoDatabase().SqlCount);
-
-            Assert.AreEqual(51, items.Length);
-
-            // There's a call or two to get languages, so apart from that there should only be one call per level.
-            Assert.Less(ScopeAccessor.AmbientScope.Database.AsUmbracoDatabase().SqlCount, 30);
-        }
-    }
-
     [Test]
     public void Can_GetLanguageById()
     {
@@ -204,35 +124,33 @@ public void Does_Not_Fail_When_DictionaryItem_Doesnt_Exist()
     }
 
     [Test]
-    public void Can_Delete_Language()
+    public async Task Can_Delete_Language()
     {
         var languageNbNo = new LanguageBuilder()
             .WithCultureInfo("nb-NO")
             .Build();
-        LocalizationService.Save(languageNbNo, Constants.Security.SuperUserId);
+        await LanguageService.CreateAsync(languageNbNo, Constants.Security.SuperUserKey);
         Assert.That(languageNbNo.HasIdentity, Is.True);
-        var languageId = languageNbNo.Id;
 
-        LocalizationService.Delete(languageNbNo);
+        await LanguageService.DeleteAsync(languageNbNo.IsoCode, Constants.Security.SuperUserKey);
 
-        var language = LocalizationService.GetLanguageById(languageId);
+        var language = await LanguageService.GetAsync(languageNbNo.IsoCode);
         Assert.Null(language);
     }
 
     [Test]
-    public void Can_Delete_Language_Used_As_Fallback()
+    public async Task Can_Delete_Language_Used_As_Fallback()
     {
-        var languageDaDk = LocalizationService.GetLanguageByIsoCode("da-DK");
+        var languageDaDk = await LanguageService.GetAsync("da-DK");
         var languageNbNo = new LanguageBuilder()
             .WithCultureInfo("nb-NO")
             .WithFallbackLanguageIsoCode(languageDaDk.IsoCode)
             .Build();
-        LocalizationService.Save(languageNbNo, Constants.Security.SuperUserId);
-        var languageId = languageDaDk.Id;
+        await LanguageService.CreateAsync(languageNbNo, Constants.Security.SuperUserKey);
 
-        LocalizationService.Delete(languageDaDk);
+        await LanguageService.DeleteAsync(languageDaDk.IsoCode, Constants.Security.SuperUserKey);
 
-        var language = LocalizationService.GetLanguageById(languageId);
+        var language = await LanguageService.GetAsync(languageDaDk.IsoCode);
         Assert.Null(language);
     }
 
@@ -257,30 +175,6 @@ public void Can_Create_DictionaryItem_At_Root()
         Assert.AreEqual(1, item.Translations.Count());
     }
 
-    [Test]
-    public void Can_Create_DictionaryItem_At_Root_With_Identity()
-    {
-        var item = LocalizationService.CreateDictionaryItemWithIdentity(
-            "Testing12345", null, "Hellooooo");
-
-        // re-get
-        item = LocalizationService.GetDictionaryItemById(item.Id);
-
-        Assert.IsNotNull(item);
-        Assert.Greater(item.Id, 0);
-        Assert.IsTrue(item.HasIdentity);
-        Assert.IsFalse(item.ParentId.HasValue);
-        Assert.AreEqual("Testing12345", item.ItemKey);
-        var allLangs = LocalizationService.GetAllLanguages();
-        Assert.Greater(allLangs.Count(), 0);
-        foreach (var language in allLangs)
-        {
-            Assert.AreEqual(
-                "Hellooooo",
-                item.Translations.Single(x => x.LanguageIsoCode == language.IsoCode).Value);
-        }
-    }
-
     [Test]
     public void Can_Add_Translation_To_Existing_Dictionary_Item()
     {
@@ -319,18 +213,6 @@ public void Can_Add_Translation_To_Existing_Dictionary_Item()
         Assert.AreEqual("My new value", item.Translations.Last().Value);
     }
 
-    [Test]
-    public void Can_Delete_DictionaryItem()
-    {
-        var item = LocalizationService.GetDictionaryItemByKey("Child");
-        Assert.NotNull(item);
-
-        LocalizationService.Delete(item);
-
-        var deletedItem = LocalizationService.GetDictionaryItemByKey("Child");
-        Assert.Null(deletedItem);
-    }
-
     [Test]
     public void Can_Update_Existing_DictionaryItem()
     {
@@ -362,7 +244,7 @@ public void Find_BaseData_Language()
     }
 
     [Test]
-    public void Save_Language_And_GetLanguageByIsoCode()
+    public async Task Save_Language_And_GetLanguageByIsoCode()
     {
         // Arrange
         var isoCode = "en-AU";
@@ -371,15 +253,15 @@ public void Save_Language_And_GetLanguageByIsoCode()
             .Build();
 
         // Act
-        LocalizationService.Save(languageEnAu);
-        var result = LocalizationService.GetLanguageByIsoCode(isoCode);
+        await LanguageService.CreateAsync(languageEnAu, Constants.Security.SuperUserKey);
+        var result = await LanguageService.GetAsync(isoCode);
 
         // Assert
         Assert.NotNull(result);
     }
 
     [Test]
-    public void Save_Language_And_GetLanguageById()
+    public async Task Save_Language_And_GetLanguageById()
     {
         // Arrange
         var languageEnAu = new LanguageBuilder()
@@ -387,22 +269,22 @@ public void Save_Language_And_GetLanguageById()
             .Build();
 
         // Act
-        LocalizationService.Save(languageEnAu);
-        var result = LocalizationService.GetLanguageById(languageEnAu.Id);
+        await LanguageService.CreateAsync(languageEnAu, Constants.Security.SuperUserKey);
+        var result = await LanguageService.GetAsync(languageEnAu.IsoCode);
 
         // Assert
         Assert.NotNull(result);
     }
 
     [Test]
-    public void Set_Default_Language()
+    public async Task Set_Default_Language()
     {
         var languageEnAu = new LanguageBuilder()
             .WithCultureInfo("en-AU")
             .WithIsDefault(true)
             .Build();
-        LocalizationService.Save(languageEnAu);
-        var result = LocalizationService.GetLanguageById(languageEnAu.Id);
+        await LanguageService.CreateAsync(languageEnAu, Constants.Security.SuperUserKey);
+        var result = await LanguageService.GetAsync(languageEnAu.IsoCode);
 
         Assert.IsTrue(result.IsDefault);
 
@@ -410,34 +292,34 @@ public void Set_Default_Language()
             .WithCultureInfo("en-NZ")
             .WithIsDefault(true)
             .Build();
-        LocalizationService.Save(languageEnNz);
-        var result2 = LocalizationService.GetLanguageById(languageEnNz.Id);
+        await LanguageService.CreateAsync(languageEnNz, Constants.Security.SuperUserKey);
+        var result2 = await LanguageService.GetAsync(languageEnNz.IsoCode);
 
         // re-get
-        result = LocalizationService.GetLanguageById(languageEnAu.Id);
+        result = await LanguageService.GetAsync(languageEnAu.IsoCode);
 
         Assert.IsTrue(result2.IsDefault);
         Assert.IsFalse(result.IsDefault);
     }
 
     [Test]
-    public void Deleted_Language_Should_Not_Exist()
+    public async Task Deleted_Language_Should_Not_Exist()
     {
         var isoCode = "en-AU";
         var languageEnAu = new LanguageBuilder()
             .WithCultureInfo(isoCode)
             .Build();
-        LocalizationService.Save(languageEnAu);
+        await LanguageService.CreateAsync(languageEnAu, Constants.Security.SuperUserKey);
 
         // Act
-        LocalizationService.Delete(languageEnAu);
-        var result = LocalizationService.GetLanguageByIsoCode(isoCode);
+        await LanguageService.DeleteAsync(languageEnAu.IsoCode, Constants.Security.SuperUserKey);
+        var result = await LanguageService.GetAsync(isoCode);
 
         // Assert
         Assert.Null(result);
     }
 
-    public void CreateTestData()
+    public async Task CreateTestData()
     {
         var languageDaDk = new LanguageBuilder()
             .WithCultureInfo("da-DK")
@@ -446,8 +328,8 @@ public void CreateTestData()
             .WithCultureInfo("en-GB")
             .Build();
 
-        LocalizationService.Save(languageDaDk, Constants.Security.SuperUserId);
-        LocalizationService.Save(languageEnGb, Constants.Security.SuperUserId);
+        await LanguageService.CreateAsync(languageDaDk, Constants.Security.SuperUserKey);
+        await LanguageService.CreateAsync(languageEnGb, Constants.Security.SuperUserKey);
         _danishLangId = languageDaDk.Id;
         _englishLangId = languageEnGb.Id;
 
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/MediaTypeServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/MediaTypeServiceTests.cs
index 8c02bd1fef1d..bfcc23b2ffb5 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/MediaTypeServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/MediaTypeServiceTests.cs
@@ -252,6 +252,30 @@ public void Cannot_Change_Alias_Of_System_Media_Type(string mediaTypeAlias)
         Assert.Throws<InvalidOperationException>(() => mediaType.Alias += "_updated");
     }
 
+    [TestCase(Constants.Conventions.MediaTypes.File)]
+    [TestCase(Constants.Conventions.MediaTypes.Folder)]
+    [TestCase(Constants.Conventions.MediaTypes.Image)]
+    public async Task Can_Copy_System_Media_Type(string mediaTypeAlias)
+    {
+        // Arrange
+        var mediaType = MediaTypeService.Get(mediaTypeAlias);
+        Assert.IsNotNull(mediaType);
+
+        // Act
+        var result = await MediaTypeService.CopyAsync(mediaType.Key, null);
+
+        // Assert
+        Assert.IsTrue(result.Success);
+        Assert.IsNotNull(result.Result);
+        Assert.AreNotEqual(mediaType.Alias, result.Result!.Alias);
+        Assert.AreNotEqual(mediaType.Id, result.Result.Id);
+        Assert.AreNotEqual(mediaType.Key, result.Result.Key);
+
+        // Verify the copy's alias can be changed (it is not system-protected)
+        result.Result.Alias = "myCustomAlias";
+        Assert.AreEqual("myCustomAlias", result.Result.Alias);
+    }
+
     [Test]
     public async Task GetAllowedParentsAsync_ReturnsEmptyCollection_WhenNoParentsAllowChildType()
     {
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/MemberServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/MemberServiceTests.cs
index f5b68870d586..14e96a1975ba 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/MemberServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/MemberServiceTests.cs
@@ -1,12 +1,16 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
+using Examine;
+using Examine.Search;
 using NUnit.Framework;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Membership;
 using Umbraco.Cms.Core.Persistence.Querying;
 using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Sync;
+using Umbraco.Cms.Infrastructure.Examine;
 using Umbraco.Cms.Infrastructure.HybridCache.Factories;
 using Umbraco.Cms.Infrastructure.Persistence;
 using Umbraco.Cms.Infrastructure.Persistence.Dtos;
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/PublicAccessServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/PublicAccessServiceTests.cs
index 0ebfbe174889..1b294b2700f8 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/PublicAccessServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/PublicAccessServiceTests.cs
@@ -1,8 +1,8 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using System.Linq;
 using NUnit.Framework;
+using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Tests.Common.Builders;
@@ -15,11 +15,12 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
 internal sealed class PublicAccessServiceTests : UmbracoIntegrationTest
 {
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
     [SetUp]
-    public void CreateTestData()
+    public async Task CreateTestData()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template); // else, FK violation on contentType!
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey); // else, FK violation on contentType!
 
         var ct = ContentTypeBuilder.CreateSimpleContentType("blah", "Blah", defaultTemplateId: template.Id);
         ContentTypeService.Save(ct);
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/RedirectUrlServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/RedirectUrlServiceTests.cs
index 952d32f54233..d09271077946 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/RedirectUrlServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/RedirectUrlServiceTests.cs
@@ -30,9 +30,9 @@ internal sealed class RedirectUrlServiceTests : UmbracoIntegrationTestWithConten
 
     private IRedirectUrlService RedirectUrlService => GetRequiredService<IRedirectUrlService>();
 
-    public override void CreateTestData()
+    public override async Task CreateTestDataAsync()
     {
-        base.CreateTestData();
+        await base.CreateTestDataAsync();
 
         using (var scope = ScopeProvider.CreateScope())
         {
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/TagServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/TagServiceTests.cs
index ac76c07cc0dc..2dae13bc39da 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/TagServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/TagServiceTests.cs
@@ -22,11 +22,12 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
 internal sealed class TagServiceTests : UmbracoIntegrationTest
 {
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
     [SetUp]
-    public void CreateTestData()
+    public async Task CreateTestData()
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template); // else, FK violation on contentType!
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey); // else, FK violation on contentType!
 
         _contentType =
             ContentTypeBuilder.CreateSimpleContentType(
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/TrackRelationsTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/TrackRelationsTests.cs
index c748b9781aad..7c0b8723e85b 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/TrackRelationsTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/TrackRelationsTests.cs
@@ -1,7 +1,5 @@
-using System.Linq;
 using NUnit.Framework;
 using Umbraco.Cms.Core;
-using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Notifications;
 using Umbraco.Cms.Core.Services;
@@ -10,7 +8,6 @@
 using Umbraco.Cms.Tests.Common.Builders;
 using Umbraco.Cms.Tests.Common.Testing;
 using Umbraco.Cms.Tests.Integration.Testing;
-using Umbraco.Extensions;
 
 namespace Umbraco.Cms.Tests.Integration.Umbraco.Infrastructure.Services;
 
@@ -31,6 +28,8 @@ internal sealed class TrackRelationsTests : UmbracoIntegrationTestWithContent
 
     private IRelationService RelationService => GetRequiredService<IRelationService>();
 
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
+
     protected override void CustomTestSetup(IUmbracoBuilder builder)
     {
         base.CustomTestSetup(builder);
@@ -40,7 +39,7 @@ protected override void CustomTestSetup(IUmbracoBuilder builder)
 
     [Test]
     [LongRunning]
-    public void Automatically_Track_Relations()
+    public async Task Automatically_Track_Relations()
     {
         var mt = MediaTypeBuilder.CreateSimpleMediaType("testMediaType", "Test Media Type");
         MediaTypeService.Save(mt);
@@ -55,7 +54,7 @@ public void Automatically_Track_Relations()
         MemberService.Save(member);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
 
         var ct = ContentTypeBuilder.CreateTextPageContentType("richTextTest", defaultTemplateId: template.Id);
         ct.AllowedTemplates = Enumerable.Empty<ITemplate>();
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/UserServiceTests.Permissions.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/UserServiceTests.Permissions.cs
index bedde499bf64..7b363e1da1a9 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/UserServiceTests.Permissions.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/UserServiceTests.Permissions.cs
@@ -271,4 +271,150 @@ public async Task GetDocumentPermissionsAsync_Returns_Failure_For_Unknown_User()
         Assert.IsFalse(result.Success);
         Assert.AreEqual(UserOperationStatus.UserNotFound, result.Status);
     }
+
+    [Test]
+    public async Task ReplaceUserGroupPermissions_Replaces_Existing_Permissions()
+    {
+        // Arrange
+        var userGroup = await CreateTestUserGroup();
+        var user = UserService.CreateUserWithIdentity("test1", "test1@test.com");
+        user.AddGroup(userGroup.ToReadOnlyGroup());
+        UserService.Save(user);
+
+        var contentType = ContentTypeBuilder.CreateSimpleContentType();
+        contentType.AllowedTemplates = null;
+        await ContentTypeService.CreateAsync(contentType, Constants.Security.SuperUserKey);
+
+        var content = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content);
+
+        // Set initial permissions
+        var initialPermissions = new HashSet<string> { ActionBrowse.ActionLetter, ActionDelete.ActionLetter };
+        UserService.ReplaceUserGroupPermissions(userGroup.Id, initialPermissions, content.Id);
+
+        // Act - replace with different permissions
+        var newPermissions = new HashSet<string> { ActionMove.ActionLetter, ActionUpdate.ActionLetter };
+        UserService.ReplaceUserGroupPermissions(userGroup.Id, newPermissions, content.Id);
+
+        // Assert - verify only the new permissions exist
+        var result = await UserService.GetDocumentPermissionsAsync(user.Key, [content.Key]);
+
+        Assert.IsTrue(result.Success);
+        var nodePermissions = result.Result.ToArray();
+        Assert.AreEqual(1, nodePermissions.Length);
+
+        // Old permissions should be gone
+        Assert.IsFalse(nodePermissions[0].Permissions.Contains(ActionBrowse.ActionLetter));
+        Assert.IsFalse(nodePermissions[0].Permissions.Contains(ActionDelete.ActionLetter));
+
+        // New permissions should be set
+        Assert.IsTrue(nodePermissions[0].Permissions.Contains(ActionMove.ActionLetter));
+        Assert.IsTrue(nodePermissions[0].Permissions.Contains(ActionUpdate.ActionLetter));
+    }
+
+    [Test]
+    public async Task ReplaceUserGroupPermissions_Sets_Permissions_On_Multiple_Entities()
+    {
+        // Arrange
+        var userGroup = await CreateTestUserGroup();
+        var user = UserService.CreateUserWithIdentity("test1", "test1@test.com");
+        user.AddGroup(userGroup.ToReadOnlyGroup());
+        UserService.Save(user);
+
+        var contentType = ContentTypeBuilder.CreateSimpleContentType();
+        contentType.AllowedTemplates = null;
+        await ContentTypeService.CreateAsync(contentType, Constants.Security.SuperUserKey);
+
+        var content1 = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content1);
+        var content2 = ContentBuilder.CreateSimpleContent(contentType, "second");
+        ContentService.Save(content2);
+
+        var permissions = new HashSet<string> { ActionBrowse.ActionLetter, ActionMove.ActionLetter };
+
+        // Act
+        UserService.ReplaceUserGroupPermissions(userGroup.Id, permissions, content1.Id, content2.Id);
+
+        // Assert - verify permissions on both content items
+        var result = await UserService.GetDocumentPermissionsAsync(user.Key, [content1.Key, content2.Key]);
+
+        Assert.IsTrue(result.Success);
+        var nodePermissions = result.Result.ToArray();
+        Assert.AreEqual(2, nodePermissions.Length);
+
+        var perms1 = nodePermissions.Single(x => x.NodeKey == content1.Key);
+        var perms2 = nodePermissions.Single(x => x.NodeKey == content2.Key);
+
+        Assert.IsTrue(perms1.Permissions.Contains(ActionBrowse.ActionLetter));
+        Assert.IsTrue(perms1.Permissions.Contains(ActionMove.ActionLetter));
+        Assert.IsTrue(perms2.Permissions.Contains(ActionBrowse.ActionLetter));
+        Assert.IsTrue(perms2.Permissions.Contains(ActionMove.ActionLetter));
+    }
+
+    [Test]
+    public async Task AssignUserGroupPermission_Sets_Permission_On_Multiple_Entities()
+    {
+        // Arrange
+        var userGroup = await CreateTestUserGroup();
+        var user = UserService.CreateUserWithIdentity("test1", "test1@test.com");
+        user.AddGroup(userGroup.ToReadOnlyGroup());
+        UserService.Save(user);
+
+        var contentType = ContentTypeBuilder.CreateSimpleContentType();
+        contentType.AllowedTemplates = null;
+        await ContentTypeService.CreateAsync(contentType, Constants.Security.SuperUserKey);
+
+        var content1 = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content1);
+        var content2 = ContentBuilder.CreateSimpleContent(contentType, "second");
+        ContentService.Save(content2);
+
+        // Act
+        UserService.AssignUserGroupPermission(userGroup.Id, ActionBrowse.ActionLetter, content1.Id, content2.Id);
+
+        // Assert - verify permissions on both content items
+        var result = await UserService.GetDocumentPermissionsAsync(user.Key, [content1.Key, content2.Key]);
+
+        Assert.IsTrue(result.Success);
+        var nodePermissions = result.Result.ToArray();
+        Assert.AreEqual(2, nodePermissions.Length);
+
+        var perms1 = nodePermissions.Single(x => x.NodeKey == content1.Key);
+        var perms2 = nodePermissions.Single(x => x.NodeKey == content2.Key);
+
+        Assert.IsTrue(perms1.Permissions.Contains(ActionBrowse.ActionLetter));
+        Assert.IsTrue(perms2.Permissions.Contains(ActionBrowse.ActionLetter));
+    }
+
+    [Test]
+    public async Task AssignUserGroupPermission_Adds_To_Existing_Permissions()
+    {
+        // Arrange
+        var userGroup = await CreateTestUserGroup();
+        var user = UserService.CreateUserWithIdentity("test1", "test1@test.com");
+        user.AddGroup(userGroup.ToReadOnlyGroup());
+        UserService.Save(user);
+
+        var contentType = ContentTypeBuilder.CreateSimpleContentType();
+        contentType.AllowedTemplates = null;
+        await ContentTypeService.CreateAsync(contentType, Constants.Security.SuperUserKey);
+
+        var content = ContentBuilder.CreateSimpleContent(contentType);
+        ContentService.Save(content);
+
+        // Set initial permission
+        UserService.AssignUserGroupPermission(userGroup.Id, ActionBrowse.ActionLetter, content.Id);
+
+        // Act - assign an additional permission
+        UserService.AssignUserGroupPermission(userGroup.Id, ActionDelete.ActionLetter, content.Id);
+
+        // Assert - both permissions should exist
+        var result = await UserService.GetDocumentPermissionsAsync(user.Key, [content.Key]);
+
+        Assert.IsTrue(result.Success);
+        var nodePermissions = result.Result.ToArray();
+        Assert.AreEqual(1, nodePermissions.Length);
+        Assert.IsTrue(nodePermissions[0].Permissions.Contains(ActionBrowse.ActionLetter));
+        Assert.IsTrue(nodePermissions[0].Permissions.Contains(ActionDelete.ActionLetter));
+    }
 }
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/UserServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/UserServiceTests.cs
index eb43d7a0ae32..d88f0cf625d8 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/UserServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/UserServiceTests.cs
@@ -31,10 +31,10 @@ internal sealed partial class UserServiceTests : UmbracoIntegrationTest
 
     private IContentTypeService ContentTypeService => GetRequiredService<IContentTypeService>();
 
-    private IFileService FileService => GetRequiredService<IFileService>();
-
     private IContentService ContentService => GetRequiredService<IContentService>();
 
+    private ITemplateService TemplateService => GetRequiredService<ITemplateService>();
+
     [Test]
     public async Task Get_User_Permissions_For_Unassigned_Permission_Nodes()
     {
@@ -42,7 +42,7 @@ public async Task Get_User_Permissions_For_Unassigned_Permission_Nodes()
         var (user, _) = await CreateTestUserAndGroup();
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         await ContentTypeService.UpdateAsync(contentType, Constants.Security.SuperUserKey);
 
@@ -70,7 +70,7 @@ public async Task Get_User_Permissions_For_Assigned_Permission_Nodes()
         var (user, userGroup) = await CreateTestUserAndGroup();
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         await ContentTypeService.UpdateAsync(contentType, Constants.Security.SuperUserKey);
 
@@ -104,7 +104,7 @@ public async Task Get_UserGroup_Assigned_Permissions()
         var userGroup = await CreateTestUserGroup();
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey); 
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         await ContentTypeService.UpdateAsync(contentType, Constants.Security.SuperUserKey);
 
@@ -139,7 +139,7 @@ public async Task Get_UserGroup_Assigned_And_Default_Permissions()
         var userGroup = await CreateTestUserGroup();
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         await ContentTypeService.UpdateAsync(contentType, Constants.Security.SuperUserKey);
 
@@ -183,7 +183,7 @@ public async Task Get_All_User_Permissions_For_All_Nodes_With_Explicit_Permissio
         UserService.Save(user);
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         await ContentTypeService.UpdateAsync(contentType, Constants.Security.SuperUserKey);
 
@@ -265,7 +265,7 @@ public async Task Get_All_User_Group_Permissions_For_All_Nodes()
         var userGroup = await CreateTestUserGroup();
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         await ContentTypeService.UpdateAsync(contentType, Constants.Security.SuperUserKey);
 
@@ -463,7 +463,7 @@ public async Task Get_User_Implicit_Permissions()
         var userGroup = await CreateTestUserGroup();
 
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         await ContentTypeService.UpdateAsync(contentType, Constants.Security.SuperUserKey);
 
@@ -1131,7 +1131,7 @@ public async Task Cannot_Create_Too_Long_ClientId(string clientId, UserClientCre
     private async Task<Content[]> BuildContentItems(int numberToCreate)
     {
         var template = TemplateBuilder.CreateTextPageTemplate();
-        FileService.SaveTemplate(template);
+        await TemplateService.CreateAsync(template, Constants.Security.SuperUserKey);
         var contentType = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: template.Id);
         await ContentTypeService.UpdateAsync(contentType, Constants.Security.SuperUserKey);
 
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/DbContext/PooledDbContextConnectionTaintingTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/DbContext/PooledDbContextConnectionTaintingTests.cs
index aee074ff33ef..31ed4d41bc3c 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/DbContext/PooledDbContextConnectionTaintingTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/DbContext/PooledDbContextConnectionTaintingTests.cs
@@ -15,7 +15,7 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Persistence.EFCore.DbContext;
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest, Logger = UmbracoTestOptions.Logger.Console)]
 public class PooledDbContextConnectionTaintingTests : UmbracoIntegrationTest
 {
-    private IEFCoreScopeProvider<PooledTestDbContext> EfCoreScopeProvider =>
+    private IEFCoreScopeProvider<PooledTestDbContext> EFCoreScopeProvider =>
         GetRequiredService<IEFCoreScopeProvider<PooledTestDbContext>>();
 
     private IDbContextFactory<PooledTestDbContext> DbContextFactory =>
@@ -41,7 +41,7 @@ public async Task Factory_Created_DbContext_Has_Valid_ConnectionString_After_Sco
         // Step 1: Use an EFCore scope to trigger InitializeDatabase() which calls
         // SetDbConnection(transaction?.Connection) on the pooled DbContext.
         // This sets a ProfiledDbConnection (from the NPoco scope) on the EF context.
-        using (IEfCoreScope<PooledTestDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<PooledTestDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async db =>
             {
@@ -64,10 +64,7 @@ await scope.ExecuteWithContextAsync<Task>(async db =>
         // Step 4: The context should be usable. Before the fix, this would throw
         // NullReferenceException at ProfiledDbConnection.get_ConnectionString() because
         // the pooled context retained a stale ProfiledDbConnection whose inner connection was null.
-        Assert.DoesNotThrowAsync(async () =>
-        {
-            await context.Database.CanConnectAsync();
-        });
+        await context.Database.CanConnectAsync();
     }
 
     /// <summary>
@@ -79,7 +76,7 @@ await scope.ExecuteWithContextAsync<Task>(async db =>
     public async Task Can_Use_Factory_DbContext_For_Migrations_After_Scope_Usage()
     {
         // Step 1: Normal data access via scope (triggers SetDbConnection)
-        using (IEfCoreScope<PooledTestDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<PooledTestDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async db =>
             {
@@ -95,17 +92,13 @@ await scope.ExecuteWithContextAsync<Task>(async db =>
         // This is what fails in the reported issue:
         // context.Database.GetPendingMigrationsAsync() eventually calls
         // ProfiledDbConnection.ConnectionString which NREs.
-        Assert.DoesNotThrowAsync(async () =>
-        {
-            // GetPendingMigrationsAsync accesses ConnectionString internally
-            var pendingMigrations = await context.Database.GetPendingMigrationsAsync();
-        });
+        await context.Database.GetPendingMigrationsAsync();
     }
 
     /// <summary>
     /// Verifies that the connection string is preserved on a pooled DbContext after an EFCore scope
     /// disposes. SetDbConnection(null) during scope disposal clears EF Core's internal connection
-    /// string field; without the restore in DisposeEfCoreDatabase, the pooled context is returned
+    /// string field; without the restore in DisposeEFCoreDatabase, the pooled context is returned
     /// with a null connection string, causing InvalidOperationException on SQL Server reuse.
     /// </summary>
     [Test]
@@ -126,7 +119,7 @@ public async Task Pooled_DbContext_Preserves_ConnectionString_After_Scope_Dispos
         Assert.IsNotNull(originalConnectionString, "Precondition: factory context should have a connection string.");
 
         // Step 2: Use and dispose an EFCore scope, which calls SetDbConnection(null) on cleanup.
-        using (IEfCoreScope<PooledTestDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<PooledTestDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async db =>
             {
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeInfrastructureScopeLockTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeInfrastructureScopeLockTests.cs
index 2e054156b017..61b101ffca54 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeInfrastructureScopeLockTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeInfrastructureScopeLockTests.cs
@@ -15,7 +15,7 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Persistence.EFCore.Scoping;
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewSchemaPerTest)]
 internal sealed class EFCoreScopeInfrastructureScopeLockTests : UmbracoIntegrationTest
 {
-    private IEFCoreScopeProvider<TestUmbracoDbContext> EfCoreScopeProvider =>
+    private IEFCoreScopeProvider<TestUmbracoDbContext> EFCoreScopeProvider =>
         GetRequiredService<IEFCoreScopeProvider<TestUmbracoDbContext>>();
 
     private IScopeProvider InfrastructureScopeProvider =>
@@ -32,7 +32,7 @@ protected override void CustomTestSetup(IUmbracoBuilder builder)
     [Test]
     public async Task ScopesCanShareNonEagerLocks()
     {
-        using IEfCoreScope<TestUmbracoDbContext> parentScope = EfCoreScopeProvider.CreateScope();
+        using IEFCoreScope<TestUmbracoDbContext> parentScope = EFCoreScopeProvider.CreateScope();
         await parentScope.ExecuteWithContextAsync<Task>(async database =>
         {
             parentScope.Locks.WriteLock(parentScope.InstanceId, Constants.Locks.Servers);
@@ -54,7 +54,7 @@ await parentScope.ExecuteWithContextAsync<Task>(async database =>
     [Test]
     public async Task ScopesCanShareEagerLocks()
     {
-        using IEfCoreScope<TestUmbracoDbContext> parentScope = EfCoreScopeProvider.CreateScope();
+        using IEFCoreScope<TestUmbracoDbContext> parentScope = EFCoreScopeProvider.CreateScope();
         await parentScope.ExecuteWithContextAsync<Task>(async database =>
         {
             parentScope.Locks.EagerWriteLock(parentScope.InstanceId, Constants.Locks.Servers);
@@ -77,7 +77,7 @@ await parentScope.ExecuteWithContextAsync<Task>(async database =>
     public void EFCoreScopeAsParent_Child_Scope_Can_Send_Notification()
     {
         var currentAssertCount = TestContext.CurrentContext.AssertCount;
-        using (var scope = EfCoreScopeProvider.CreateScope())
+        using (var scope = EFCoreScopeProvider.CreateScope())
         {
             using (var childScope = InfrastructureScopeProvider.CreateScope())
             {
@@ -101,7 +101,7 @@ public void InfrastructureScopeAsParent_Child_Scope_Can_Send_Notification()
         var currentAssertCount = TestContext.CurrentContext.AssertCount;
         using (var scope = InfrastructureScopeProvider.CreateScope())
         {
-            using (var childScope = EfCoreScopeProvider.CreateScope())
+            using (var childScope = EFCoreScopeProvider.CreateScope())
             {
                 var savingNotification = new TestSendNotification();
                 childScope.Notifications.Publish(savingNotification);
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeInfrastructureScopeTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeInfrastructureScopeTests.cs
index 01696a9f9134..11bf85d34325 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeInfrastructureScopeTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeInfrastructureScopeTests.cs
@@ -13,26 +13,26 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Persistence.EFCore.Scoping;
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewEmptyPerTest)]
 internal sealed class EFCoreScopeInfrastructureScopeTests : UmbracoIntegrationTest
 {
-    private IEFCoreScopeProvider<TestUmbracoDbContext> EfCoreScopeProvider =>
+    private IEFCoreScopeProvider<TestUmbracoDbContext> EFCoreScopeProvider =>
         GetRequiredService<IEFCoreScopeProvider<TestUmbracoDbContext>>();
 
     private IScopeProvider InfrastructureScopeProvider =>
         GetRequiredService<IScopeProvider>();
 
-    private EFCoreScopeAccessor<TestUmbracoDbContext> EfCoreScopeAccessor => (EFCoreScopeAccessor<TestUmbracoDbContext>)GetRequiredService<IEFCoreScopeAccessor<TestUmbracoDbContext>>();
+    private EFCoreScopeAccessor<TestUmbracoDbContext> EFCoreScopeAccessor => (EFCoreScopeAccessor<TestUmbracoDbContext>)GetRequiredService<IEFCoreScopeAccessor<TestUmbracoDbContext>>();
 
     private IScopeAccessor InfrastructureScopeAccessor => GetRequiredService<IScopeAccessor>();
 
     [Test]
     public void CanCreateNestedInfrastructureScope()
     {
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             Assert.IsInstanceOf<EFCoreScope<TestUmbracoDbContext>>(scope);
-            Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
+            Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
             Assert.IsNotNull(InfrastructureScopeAccessor.AmbientScope);
-            Assert.AreSame(scope, EfCoreScopeAccessor.AmbientScope);
+            Assert.AreSame(scope, EFCoreScopeAccessor.AmbientScope);
             using (var infrastructureScope = InfrastructureScopeProvider.CreateScope())
             {
                 Assert.AreSame(infrastructureScope, InfrastructureScopeAccessor.AmbientScope);
@@ -41,14 +41,14 @@ public void CanCreateNestedInfrastructureScope()
             Assert.IsNotNull(InfrastructureScopeAccessor.AmbientScope);
         }
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
         Assert.IsNull(InfrastructureScopeAccessor.AmbientScope);
     }
 
     [Test]
-    public async Task? TransactionWithEfCoreScopeAsParent()
+    public async Task? TransactionWithEFCoreScopeAsParent()
     {
-        using (IEfCoreScope<TestUmbracoDbContext> parentScope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> parentScope = EFCoreScopeProvider.CreateScope())
         {
             await parentScope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -76,7 +76,7 @@ await parentScope.ExecuteWithContextAsync<Task>(async database =>
         }
 
         // Check that its not rolled back
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -93,7 +93,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
         {
             parentScope.Database.Execute("CREATE TABLE tmp3 (id INT, name NVARCHAR(64))");
 
-            using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+            using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
             {
                 await scope.ExecuteWithContextAsync<Task>(async database =>
                 {
@@ -111,7 +111,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
         }
 
         // Check that its not rolled back
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -124,7 +124,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
     [Test]
     public async Task EFCoreAsParent_DontCompleteWhenChildScopeDoesNotComplete()
     {
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -133,7 +133,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
             scope.Complete();
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> parentScope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> parentScope = EFCoreScopeProvider.CreateScope())
         {
             using (IScope scope = InfrastructureScopeProvider.CreateScope())
             {
@@ -153,7 +153,7 @@ await parentScope.ExecuteWithContextAsync<Task>(async database =>
         }
 
         // Check that its rolled back
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -167,7 +167,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
     [Test]
     public async Task InfrastructureScopeAsParent_DontCompleteWhenChildScopeDoesNotComplete()
     {
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -179,7 +179,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
 
         using (IScope parentScope = InfrastructureScopeProvider.CreateScope())
         {
-            using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+            using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
             {
                 await scope.ExecuteWithContextAsync<Task>(async database =>
                 {
@@ -197,7 +197,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
         }
 
         // Check that its rolled back
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -222,7 +222,7 @@ public async Task BridgedScope_NPocoScopeAccessesEfCoreRepository_SharesTransact
 
             // Simulate an EF Core repository accessing the ambient scope via the accessor.
             // Since only an NPoco scope is active, the accessor auto-creates a bridge scope.
-            var bridgedScope = EfCoreScopeAccessor.AmbientScope;
+            var bridgedScope = EFCoreScopeAccessor.AmbientScope;
             Assert.IsNotNull(bridgedScope);
             Assert.IsTrue(((EFCoreScope<TestUmbracoDbContext>)bridgedScope!).IsBridgeScope);
 
@@ -249,7 +249,7 @@ await db.Database.ExecuteSqlAsync(
         }
 
         // Both rows committed
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async db =>
             {
@@ -282,7 +282,7 @@ public async Task BridgedScope_NPocoScopeNotCompleted_EfCoreWritesRolledBack()
         using (IScope npocoScope = InfrastructureScopeProvider.CreateScope())
         {
             // Simulate EF Core repository access — triggers bridge scope creation
-            IEfCoreScope<TestUmbracoDbContext>? bridgeScope = EfCoreScopeAccessor.AmbientScope;
+            IEFCoreScope<TestUmbracoDbContext>? bridgeScope = EFCoreScopeAccessor.AmbientScope;
             Assert.IsNotNull(bridgeScope);
 
             await bridgeScope!.ExecuteWithContextAsync<Task>(async db =>
@@ -300,7 +300,7 @@ await db.Database.ExecuteSqlAsync(
         }
 
         // Verify rolled back
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async db =>
             {
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeNotificationsTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeNotificationsTest.cs
index 3b7fc9f06b4c..72f12f75b1ae 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeNotificationsTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeNotificationsTest.cs
@@ -20,7 +20,7 @@ protected override void CustomTestSetup(IUmbracoBuilder builder)
         builder.AddNotificationHandler<TestDoNotSendNotification, TestDoNotSendNotificationHandler>();
     }
 
-    private IEFCoreScopeProvider<TestUmbracoDbContext> EfCoreScopeProvider => GetRequiredService<IEFCoreScopeProvider<TestUmbracoDbContext>>();
+    private IEFCoreScopeProvider<TestUmbracoDbContext> EFCoreScopeProvider => GetRequiredService<IEFCoreScopeProvider<TestUmbracoDbContext>>();
 
     [Test]
     public void Scope_Can_Send_Notification()
@@ -30,7 +30,7 @@ public void Scope_Can_Send_Notification()
         // has only gone up by 1
         var initialAssertCount = TestContext.CurrentContext.AssertCount;
 
-        using (var scope = EfCoreScopeProvider.CreateScope())
+        using (var scope = EFCoreScopeProvider.CreateScope())
         {
             var savingNotification = new TestSendNotification();
             scope.Notifications.Publish(savingNotification);
@@ -44,9 +44,9 @@ public void Scope_Can_Send_Notification()
     public void Child_Scope_Can_Send_Notification()
     {
         var initialAssertCount = TestContext.CurrentContext.AssertCount;
-        using (var scope = EfCoreScopeProvider.CreateScope())
+        using (var scope = EFCoreScopeProvider.CreateScope())
         {
-            using (var childScope = EfCoreScopeProvider.CreateScope())
+            using (var childScope = EFCoreScopeProvider.CreateScope())
             {
                 var savingNotification = new TestSendNotification();
                 childScope.Notifications.Publish(savingNotification);
@@ -62,7 +62,7 @@ public void Child_Scope_Can_Send_Notification()
     [Test]
     public void Scope_Does_Not_Send_Notification_When_Not_Completed()
     {
-        using var scope = EfCoreScopeProvider.CreateScope();
+        using var scope = EFCoreScopeProvider.CreateScope();
 
         var savingNotification = new TestDoNotSendNotification();
         scope.Notifications.Publish(savingNotification);
@@ -71,7 +71,7 @@ public void Scope_Does_Not_Send_Notification_When_Not_Completed()
     [Test]
     public void Scope_Does_Not_Send_Notification_When_Suppressing()
     {
-        using var scope = EfCoreScopeProvider.CreateScope();
+        using var scope = EFCoreScopeProvider.CreateScope();
         scope.Notifications.Suppress();
         var savingNotification = new TestDoNotSendNotification();
         scope.Notifications.Publish(savingNotification);
@@ -81,9 +81,9 @@ public void Scope_Does_Not_Send_Notification_When_Suppressing()
     [Test]
     public void Child_Scope_Cannot_Send_Suppressed_Notification()
     {
-        using var scope = EfCoreScopeProvider.CreateScope();
+        using var scope = EFCoreScopeProvider.CreateScope();
 
-        using (var childScope = EfCoreScopeProvider.CreateScope())
+        using (var childScope = EFCoreScopeProvider.CreateScope())
         {
             childScope.Notifications.Suppress();
             var savingNotification = new TestDoNotSendNotification();
@@ -98,11 +98,11 @@ public void Parent_Scope_Can_Send_Notification_Before_Child_Suppressing()
     {
         var initialAssertCount = TestContext.CurrentContext.AssertCount;
 
-        using (var scope = EfCoreScopeProvider.CreateScope())
+        using (var scope = EFCoreScopeProvider.CreateScope())
         {
             var savingParentNotification = new TestSendNotification();
             scope.Notifications.Publish(savingParentNotification);
-            using (var childScope = EfCoreScopeProvider.CreateScope())
+            using (var childScope = EFCoreScopeProvider.CreateScope())
             {
                 childScope.Notifications.Suppress();
                 var savingNotification = new TestDoNotSendNotification();
@@ -122,9 +122,9 @@ public void Parent_Scope_Can_Send_Notification_After_Child_Suppressing()
         var initialAssertCount = TestContext.CurrentContext.AssertCount;
 
 
-        using (var scope = EfCoreScopeProvider.CreateScope())
+        using (var scope = EFCoreScopeProvider.CreateScope())
         {
-            using (var childScope = EfCoreScopeProvider.CreateScope())
+            using (var childScope = EFCoreScopeProvider.CreateScope())
             {
                 using (childScope.Notifications.Suppress())
                 {
@@ -148,7 +148,7 @@ public void Scope_Can_Send_Notification_After_Suppression_Disposed()
     {
         var initialAssertCount = TestContext.CurrentContext.AssertCount;
 
-        using (var scope = EfCoreScopeProvider.CreateScope())
+        using (var scope = EFCoreScopeProvider.CreateScope())
         {
             using (scope.Notifications.Suppress())
             {
@@ -168,10 +168,10 @@ public void Scope_Can_Send_Notification_After_Suppression_Disposed()
     [Test]
     public void Child_Scope_Does_Not_Send_Notification_When_Parent_Suppressing()
     {
-        using var scope = EfCoreScopeProvider.CreateScope();
+        using var scope = EFCoreScopeProvider.CreateScope();
         scope.Notifications.Suppress();
 
-        using (var childScope = EfCoreScopeProvider.CreateScope())
+        using (var childScope = EFCoreScopeProvider.CreateScope())
         {
             var savingNotification = new TestDoNotSendNotification();
             childScope.Notifications.Publish(savingNotification);
@@ -182,11 +182,11 @@ public void Child_Scope_Does_Not_Send_Notification_When_Parent_Suppressing()
     }
 
     [Test]
-    public void Cant_Suppress_Notifactions_On_Child_When_Parent_Suppressing()
+    public void Cant_Suppress_Notifications_On_Child_When_Parent_Suppressing()
     {
-        using var parentScope = EfCoreScopeProvider.CreateScope();
+        using var parentScope = EFCoreScopeProvider.CreateScope();
         using var parentSuppressed = parentScope.Notifications.Suppress();
-        using var childScope = EfCoreScopeProvider.CreateScope();
+        using var childScope = EFCoreScopeProvider.CreateScope();
         Assert.Throws<InvalidOperationException>(() => childScope.Notifications.Suppress());
     }
 
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeTest.cs
index 5fe9a9a15a05..fea8cdefc035 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopeTest.cs
@@ -18,35 +18,35 @@ namespace Umbraco.Cms.Tests.Integration.Umbraco.Persistence.EFCore.Scoping;
 [UmbracoTest(Database = UmbracoTestOptions.Database.NewEmptyPerTest)]
 internal sealed class EFCoreScopeTest : UmbracoIntegrationTest
 {
-    private IEFCoreScopeProvider<TestUmbracoDbContext> EfCoreScopeProvider =>
+    private IEFCoreScopeProvider<TestUmbracoDbContext> EFCoreScopeProvider =>
         GetRequiredService<IEFCoreScopeProvider<TestUmbracoDbContext>>();
 
-    private EFCoreScopeAccessor<TestUmbracoDbContext> EfCoreScopeAccessor => (EFCoreScopeAccessor<TestUmbracoDbContext>)GetRequiredService<IEFCoreScopeAccessor<TestUmbracoDbContext>>();
+    private EFCoreScopeAccessor<TestUmbracoDbContext> EFCoreScopeAccessor => (EFCoreScopeAccessor<TestUmbracoDbContext>)GetRequiredService<IEFCoreScopeAccessor<TestUmbracoDbContext>>();
 
     [Test]
     public void CanCreateScope()
     {
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             Assert.IsInstanceOf<EFCoreScope<TestUmbracoDbContext>>(scope);
-            Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
-            Assert.AreSame(scope, EfCoreScopeAccessor.AmbientScope);
+            Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
+            Assert.AreSame(scope, EFCoreScopeAccessor.AmbientScope);
         }
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
     }
 
     [Test]
     public void CanCreateScopeTwice() =>
         Assert.DoesNotThrow(() =>
         {
-            using (var scope = EfCoreScopeProvider.CreateScope())
+            using (var scope = EFCoreScopeProvider.CreateScope())
             {
                 scope.Complete();
             }
 
-            using (var scopeTwo = EfCoreScopeProvider.CreateScope())
+            using (var scopeTwo = EFCoreScopeProvider.CreateScope())
             {
                 scopeTwo.Complete();
             }
@@ -55,22 +55,22 @@ public void CanCreateScopeTwice() =>
     [Test]
     public void NestedCreateScope()
     {
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             Assert.IsInstanceOf<EFCoreScope<TestUmbracoDbContext>>(scope);
-            Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
-            Assert.AreSame(scope, EfCoreScopeAccessor.AmbientScope);
-            using (IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope())
+            Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
+            Assert.AreSame(scope, EFCoreScopeAccessor.AmbientScope);
+            using (IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope())
             {
                 Assert.IsInstanceOf<EFCoreScope<TestUmbracoDbContext>>(nested);
-                Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
-                Assert.AreSame(nested, EfCoreScopeAccessor.AmbientScope);
+                Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
+                Assert.AreSame(nested, EFCoreScopeAccessor.AmbientScope);
                 Assert.AreSame(scope, ((EFCoreScope<TestUmbracoDbContext>)nested).ParentScope);
             }
         }
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
     }
 
     [Test]
@@ -78,23 +78,23 @@ public async Task NestedCreateScopeInnerException()
     {
         bool scopeCompleted = false;
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
         try
         {
-            using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+            using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
             {
                 // scopeProvider.Context.Enlist("test", completed => scopeCompleted = completed);
                 await scope.ExecuteWithContextAsync(database =>
                 {
                     scope.ScopeContext!.Enlist("test", completed => scopeCompleted = completed);
                     Assert.IsInstanceOf<EFCoreScope<TestUmbracoDbContext>>(scope);
-                    Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
-                    Assert.AreSame(scope, EfCoreScopeAccessor.AmbientScope);
-                    using (IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope())
+                    Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
+                    Assert.AreSame(scope, EFCoreScopeAccessor.AmbientScope);
+                    using (IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope())
                     {
                         Assert.IsInstanceOf<EFCoreScope<TestUmbracoDbContext>>(nested);
-                        Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
-                        Assert.AreSame(nested, EfCoreScopeAccessor.AmbientScope);
+                        Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
+                        Assert.AreSame(nested, EFCoreScopeAccessor.AmbientScope);
                         Assert.AreSame(scope, ((EFCoreScope<TestUmbracoDbContext>)nested).ParentScope);
                         nested.Complete();
                         throw new Exception("bang!");
@@ -116,14 +116,14 @@ await scope.ExecuteWithContextAsync(database =>
             }
         }
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
         Assert.IsFalse(scopeCompleted);
     }
 
     [Test]
     public async Task CanAccessDbContext()
     {
-        using var scope = EfCoreScopeProvider.CreateScope();
+        using var scope = EFCoreScopeProvider.CreateScope();
         await scope.ExecuteWithContextAsync<Task>(async database =>
         {
             Assert.IsTrue(await database.Database.CanConnectAsync());
@@ -135,7 +135,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
     [Test]
     public async Task CanAccessDbContextTwice()
     {
-        using (var scope = EfCoreScopeProvider.CreateScope())
+        using (var scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -145,7 +145,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
             scope.Complete();
         }
 
-        using (var scopeTwo = EfCoreScopeProvider.CreateScope())
+        using (var scopeTwo = EFCoreScopeProvider.CreateScope())
         {
             await scopeTwo.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -160,16 +160,16 @@ await scopeTwo.ExecuteWithContextAsync<Task>(async database =>
     [Test]
     public async Task CanAccessNestedDbContext()
     {
-        using (var scope = EfCoreScopeProvider.CreateScope())
+        using (var scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
                 Assert.IsTrue(await database.Database.CanConnectAsync());
                 var parentTransaction = database.Database.CurrentTransaction;
 
-                using (var nestedSCope = EfCoreScopeProvider.CreateScope())
+                using (var nestedScope = EFCoreScopeProvider.CreateScope())
                 {
-                    await nestedSCope.ExecuteWithContextAsync<Task>(async nestedDatabase =>
+                    await nestedScope.ExecuteWithContextAsync<Task>(async nestedDatabase =>
                     {
                         Assert.IsTrue(await nestedDatabase.Database.CanConnectAsync());
                         Assert.IsNotNull(nestedDatabase.Database.CurrentTransaction); // in a transaction
@@ -185,12 +185,12 @@ await nestedSCope.ExecuteWithContextAsync<Task>(async nestedDatabase =>
     [Test]
     public void GivenUncompletedScopeOnChildThread_WhenTheParentCompletes_TheTransactionIsRolledBack()
     {
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        IEfCoreScope<TestUmbracoDbContext> mainScope = EfCoreScopeProvider.CreateScope();
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        IEFCoreScope<TestUmbracoDbContext> mainScope = EFCoreScopeProvider.CreateScope();
 
         var t = Task.Run(() =>
         {
-            IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope();
+            IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope();
             Thread.Sleep(2000);
             nested.Dispose();
         });
@@ -205,10 +205,10 @@ public void GivenUncompletedScopeOnChildThread_WhenTheParentCompletes_TheTransac
     [Test]
     public void GivenNonDisposedChildScope_WhenTheParentDisposes_ThenInvalidOperationExceptionThrows()
     {
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        IEfCoreScope<TestUmbracoDbContext> mainScope = EfCoreScopeProvider.CreateScope();
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        IEFCoreScope<TestUmbracoDbContext> mainScope = EFCoreScopeProvider.CreateScope();
 
-        IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope(); // not disposing
+        IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope(); // not disposing
 
         InvalidOperationException ex = Assert.Throws<InvalidOperationException>(() => mainScope.Dispose());
         Console.WriteLine(ex);
@@ -217,41 +217,41 @@ public void GivenNonDisposedChildScope_WhenTheParentDisposes_ThenInvalidOperatio
     [Test]
     public void GivenChildThread_WhenParentDisposedBeforeChild_ParentScopeThrows()
     {
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        IEfCoreScope<TestUmbracoDbContext> mainScope = EfCoreScopeProvider.CreateScope();
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        IEFCoreScope<TestUmbracoDbContext> mainScope = EFCoreScopeProvider.CreateScope();
 
         var t = Task.Run(() =>
         {
-            Console.WriteLine("Child Task start: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+            Console.WriteLine("Child Task start: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
 
             // This will push the child scope to the top of the Stack
-            IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope();
-            Console.WriteLine("Child Task scope created: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+            IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope();
+            Console.WriteLine("Child Task scope created: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
             Thread.Sleep(5000); // block for a bit to ensure the parent task is disposed first
-            Console.WriteLine("Child Task before dispose: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+            Console.WriteLine("Child Task before dispose: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
             nested.Dispose();
-            Console.WriteLine("Child Task after dispose: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+            Console.WriteLine("Child Task after dispose: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
         });
 
         // provide some time for the child thread to start so the ambient context is copied in AsyncLocal
         Thread.Sleep(2000);
 
         // now dispose the main without waiting for the child thread to join
-        Console.WriteLine("Parent Task disposing: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+        Console.WriteLine("Parent Task disposing: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
 
         // This will throw because at this stage a child scope has been created which means
         // it is the Ambient (top) scope but here we're trying to dispose the non top scope.
         Assert.Throws<InvalidOperationException>(() => mainScope.Dispose());
         t.Wait(); // wait for the child to dispose
         mainScope.Dispose(); // now it's ok
-        Console.WriteLine("Parent Task disposed: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+        Console.WriteLine("Parent Task disposed: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
     }
 
     [Test]
     public void GivenChildThread_WhenChildDisposedBeforeParent_OK()
     {
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        IEfCoreScope<TestUmbracoDbContext> mainScope = EfCoreScopeProvider.CreateScope();
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        IEFCoreScope<TestUmbracoDbContext> mainScope = EFCoreScopeProvider.CreateScope();
 
         // Task.Run will flow the execution context unless ExecutionContext.SuppressFlow() is explicitly called.
         // This is what occurs in normal async behavior since it is expected to await (and join) the main thread,
@@ -259,18 +259,18 @@ public void GivenChildThread_WhenChildDisposedBeforeParent_OK()
         // flow to that thread.
         var t = Task.Run(() =>
         {
-            Console.WriteLine("Child Task start: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
-            IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope();
-            Console.WriteLine("Child Task before dispose: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+            Console.WriteLine("Child Task start: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
+            IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope();
+            Console.WriteLine("Child Task before dispose: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
             nested.Dispose();
-            Console.WriteLine("Child Task after disposed: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+            Console.WriteLine("Child Task after disposed: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
         });
 
-        Console.WriteLine("Parent Task waiting: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+        Console.WriteLine("Parent Task waiting: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
         t.Wait();
-        Console.WriteLine("Parent Task disposing: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+        Console.WriteLine("Parent Task disposing: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
         mainScope.Dispose();
-        Console.WriteLine("Parent Task disposed: " + EfCoreScopeAccessor.AmbientScope?.InstanceId);
+        Console.WriteLine("Parent Task disposed: " + EFCoreScopeAccessor.AmbientScope?.InstanceId);
 
         Assert.Pass();
     }
@@ -278,7 +278,7 @@ public void GivenChildThread_WhenChildDisposedBeforeParent_OK()
     [Test]
     public async Task Transaction()
     {
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -287,7 +287,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
             scope.Complete();
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -298,7 +298,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
             });
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -307,7 +307,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
             });
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -317,7 +317,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
             scope.Complete();
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -332,7 +332,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
     [Test]
     public async Task NestedTransactionInnerFail()
     {
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -342,7 +342,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
             scope.Complete();
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             string n;
             await scope.ExecuteWithContextAsync<Task>(async database =>
@@ -351,7 +351,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
                 n = await database.Database.ExecuteScalarAsync<string>("SELECT name FROM tmp1 WHERE id=1");
                 Assert.AreEqual("a", n);
 
-                using (IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope())
+                using (IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope())
                 {
                     await nested.ExecuteWithContextAsync<Task>(async nestedDatabase =>
                     {
@@ -369,7 +369,7 @@ await nested.ExecuteWithContextAsync<Task>(async nestedDatabase =>
             scope.Complete();
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -384,7 +384,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
     [Test]
     public async Task NestedTransactionOuterFail()
     {
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -394,7 +394,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
             scope.Complete();
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -402,7 +402,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
                 string n = await database.Database.ExecuteScalarAsync<string>("SELECT name FROM tmp2 WHERE id=1");
                 Assert.AreEqual("a", n);
 
-                using (IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope())
+                using (IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope())
                 {
                     await scope.ExecuteWithContextAsync<Task>(async nestedDatabase =>
                     {
@@ -420,7 +420,7 @@ await scope.ExecuteWithContextAsync<Task>(async nestedDatabase =>
             });
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -435,7 +435,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
     [Test]
     public async Task NestedTransactionComplete()
     {
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -444,7 +444,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
             scope.Complete();
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -452,7 +452,7 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
                 string n = await database.Database.ExecuteScalarAsync<string>("SELECT name FROM tmp WHERE id=1");
                 Assert.AreEqual("a", n);
 
-                using (IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope())
+                using (IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope())
                 {
                     await scope.ExecuteWithContextAsync<Task>(async nestedDatabase =>
                     {
@@ -472,7 +472,7 @@ await scope.ExecuteWithContextAsync<Task>(async nestedDatabase =>
             scope.Complete();
         }
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             await scope.ExecuteWithContextAsync<Task>(async database =>
             {
@@ -488,67 +488,67 @@ await scope.ExecuteWithContextAsync<Task>(async database =>
     public void CallContextScope1()
     {
         var taskHelper = new TaskHelper(Mock.Of<ILogger<TaskHelper>>());
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
-            Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
+            Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
 
             // Run on another thread without a flowed context
             Task t = taskHelper.ExecuteBackgroundTask(() =>
             {
-                Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+                Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
 
-                using (IEfCoreScope<TestUmbracoDbContext> newScope = EfCoreScopeProvider.CreateScope())
+                using (IEFCoreScope<TestUmbracoDbContext> newScope = EFCoreScopeProvider.CreateScope())
                 {
-                    Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
-                    Assert.IsNull(EfCoreScopeAccessor.AmbientScope.ParentScope);
+                    Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
+                    Assert.IsNull(EFCoreScopeAccessor.AmbientScope.ParentScope);
                 }
 
-                Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+                Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
 
                 return Task.CompletedTask;
             });
 
             Task.WaitAll(t);
 
-            Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
-            Assert.AreSame(scope, EfCoreScopeAccessor.AmbientScope);
+            Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
+            Assert.AreSame(scope, EFCoreScopeAccessor.AmbientScope);
         }
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
     }
 
     [Test]
     public void CallContextScope2()
     {
         var taskHelper = new TaskHelper(Mock.Of<ILogger<TaskHelper>>());
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
 
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
-            Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
+            Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
 
             // Run on another thread without a flowed context
             Task t = taskHelper.ExecuteBackgroundTask(() =>
             {
-                Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+                Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
 
-                using (IEfCoreScope<TestUmbracoDbContext> newScope = EfCoreScopeProvider.CreateScope())
+                using (IEFCoreScope<TestUmbracoDbContext> newScope = EFCoreScopeProvider.CreateScope())
                 {
-                    Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
-                    Assert.IsNull(EfCoreScopeAccessor.AmbientScope.ParentScope);
+                    Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
+                    Assert.IsNull(EFCoreScopeAccessor.AmbientScope.ParentScope);
                 }
 
-                Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+                Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
                 return Task.CompletedTask;
             });
 
             Task.WaitAll(t);
 
-            Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
-            Assert.AreSame(scope, EfCoreScopeAccessor.AmbientScope);
+            Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
+            Assert.AreSame(scope, EFCoreScopeAccessor.AmbientScope);
         }
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
     }
 
     [TestCase(true)]
@@ -556,17 +556,17 @@ public void CallContextScope2()
     public void ScopeContextEnlist(bool complete)
     {
         bool? completed = null;
-        IEfCoreScope<TestUmbracoDbContext> ambientScope = null;
+        IEFCoreScope<TestUmbracoDbContext> ambientScope = null;
         IScopeContext ambientContext = null;
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             scope.ScopeContext.Enlist("name", c =>
             {
                 completed = c;
-                ambientScope = EfCoreScopeAccessor.AmbientScope;
-                ambientContext = EfCoreScopeProvider.AmbientScopeContext;
+                ambientScope = EFCoreScopeAccessor.AmbientScope;
+                ambientContext = EFCoreScopeProvider.AmbientScopeContext;
             });
             if (complete)
             {
@@ -574,8 +574,8 @@ public void ScopeContextEnlist(bool complete)
             }
         }
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        Assert.IsNull(EfCoreScopeProvider.AmbientScopeContext);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeProvider.AmbientScopeContext);
         Assert.IsNotNull(completed);
         Assert.AreEqual(complete, completed.Value);
         Assert.IsNull(ambientScope); // the scope is gone
@@ -591,7 +591,7 @@ public void ScopeContextEnlist(bool complete)
     public async Task NestedScope_ChildFirstDbAccess_CanWriteViaNPoco()
     {
         // Setup: create a table to write to.
-        using (IEfCoreScope<TestUmbracoDbContext> setup = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> setup = EFCoreScopeProvider.CreateScope())
         {
             await setup.ExecuteWithContextAsync<Task>(async db =>
                 await db.Database.ExecuteSqlAsync($"CREATE TABLE tmp4 (id INT, name NVARCHAR(64))"));
@@ -603,10 +603,10 @@ await setup.ExecuteWithContextAsync<Task>(async db =>
         // This reproduces the scenario that caused SQLite locking errors:
         // an outer EF Core scope where the NESTED scope is the first to access
         // the database, followed by a NPoco write on the same scope hierarchy.
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             // Write via a nested EF Core scope (first DB access in this hierarchy).
-            using (IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope())
+            using (IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope())
             {
                 await nested.ExecuteWithContextAsync<Task>(async db =>
                     await db.Database.ExecuteSqlAsync($"INSERT INTO tmp4 (id, name) VALUES (1, 'efcore')"));
@@ -622,7 +622,7 @@ await nested.ExecuteWithContextAsync<Task>(async db =>
         }
 
         // Verify both writes were committed.
-        using (IEfCoreScope<TestUmbracoDbContext> verify = EfCoreScopeProvider.CreateScope())
+        using (IEFCoreScope<TestUmbracoDbContext> verify = EFCoreScopeProvider.CreateScope())
         {
             await verify.ExecuteWithContextAsync<Task>(async db =>
             {
@@ -642,15 +642,15 @@ public void ScopeContextEnlistAgain(bool complete)
         bool? completed = null;
         bool? completed2 = null;
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             scope.ScopeContext.Enlist("name", c =>
             {
                 completed = c;
 
                 // at that point the scope is gone, but the context is still there
-                IScopeContext ambientContext = EfCoreScopeProvider.AmbientScopeContext;
+                IScopeContext ambientContext = EFCoreScopeProvider.AmbientScopeContext;
                 ambientContext.Enlist("another", c2 => completed2 = c2);
             });
             if (complete)
@@ -659,8 +659,8 @@ public void ScopeContextEnlistAgain(bool complete)
             }
         }
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        Assert.IsNull(EfCoreScopeProvider.AmbientScopeContext);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeProvider.AmbientScopeContext);
         Assert.IsNotNull(completed);
         Assert.AreEqual(complete, completed.Value);
         Assert.AreEqual(complete, completed2.Value);
@@ -669,41 +669,41 @@ public void ScopeContextEnlistAgain(bool complete)
     [Test]
     public void DetachableScope()
     {
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        using (IEfCoreScope<TestUmbracoDbContext> scope = EfCoreScopeProvider.CreateScope())
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        using (IEFCoreScope<TestUmbracoDbContext> scope = EFCoreScopeProvider.CreateScope())
         {
             Assert.IsInstanceOf<EFCoreScope<TestUmbracoDbContext>>(scope);
-            Assert.IsNotNull(EfCoreScopeAccessor.AmbientScope);
-            Assert.AreSame(scope, EfCoreScopeAccessor.AmbientScope);
+            Assert.IsNotNull(EFCoreScopeAccessor.AmbientScope);
+            Assert.AreSame(scope, EFCoreScopeAccessor.AmbientScope);
 
-            Assert.IsNotNull(EfCoreScopeProvider.AmbientScopeContext); // the ambient context
+            Assert.IsNotNull(EFCoreScopeProvider.AmbientScopeContext); // the ambient context
             Assert.IsNotNull(scope.ScopeContext); // the ambient context too (getter only)
             IScopeContext context = scope.ScopeContext;
 
-            IEfCoreScope<TestUmbracoDbContext> detached = EfCoreScopeProvider.CreateDetachedScope();
-            EfCoreScopeProvider.AttachScope(detached);
+            IEFCoreScope<TestUmbracoDbContext> detached = EFCoreScopeProvider.CreateDetachedScope();
+            EFCoreScopeProvider.AttachScope(detached);
 
-            Assert.AreEqual(detached, EfCoreScopeAccessor.AmbientScope);
-            Assert.AreNotSame(context, EfCoreScopeProvider.AmbientScopeContext);
+            Assert.AreEqual(detached, EFCoreScopeAccessor.AmbientScope);
+            Assert.AreNotSame(context, EFCoreScopeProvider.AmbientScopeContext);
 
             // nesting under detached!
-            using (IEfCoreScope<TestUmbracoDbContext> nested = EfCoreScopeProvider.CreateScope())
+            using (IEFCoreScope<TestUmbracoDbContext> nested = EFCoreScopeProvider.CreateScope())
             {
                 Assert.Throws<InvalidOperationException>(() =>
 
                     // cannot detach a non-detachable scope
-                    EfCoreScopeProvider.DetachScope());
+                    EFCoreScopeProvider.DetachScope());
                 nested.Complete();
             }
 
-            Assert.AreEqual(detached, EfCoreScopeAccessor.AmbientScope);
-            Assert.AreNotSame(context, EfCoreScopeProvider.AmbientScopeContext);
+            Assert.AreEqual(detached, EFCoreScopeAccessor.AmbientScope);
+            Assert.AreNotSame(context, EFCoreScopeProvider.AmbientScopeContext);
 
             // can detach
-            Assert.AreSame(detached, EfCoreScopeProvider.DetachScope());
+            Assert.AreSame(detached, EFCoreScopeProvider.DetachScope());
 
-            Assert.AreSame(scope, EfCoreScopeAccessor.AmbientScope);
-            Assert.AreSame(context, EfCoreScopeProvider.AmbientScopeContext);
+            Assert.AreSame(scope, EFCoreScopeAccessor.AmbientScope);
+            Assert.AreSame(context, EFCoreScopeProvider.AmbientScopeContext);
 
             Assert.Throws<InvalidOperationException>(() =>
 
@@ -711,16 +711,16 @@ public void DetachableScope()
                 // in fact, only the ambient scope can be disposed
                 detached.Dispose());
 
-            EfCoreScopeProvider.AttachScope(detached);
+            EFCoreScopeProvider.AttachScope(detached);
             detached.Complete();
             detached.Dispose();
 
             // has self-detached, and is gone!
-            Assert.AreSame(scope, EfCoreScopeAccessor.AmbientScope);
-            Assert.AreSame(context, EfCoreScopeProvider.AmbientScopeContext);
+            Assert.AreSame(scope, EFCoreScopeAccessor.AmbientScope);
+            Assert.AreSame(context, EFCoreScopeProvider.AmbientScopeContext);
         }
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
-        Assert.IsNull(EfCoreScopeProvider.AmbientScopeContext);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeProvider.AmbientScopeContext);
     }
 }
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopedFileSystemsTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopedFileSystemsTests.cs
index 7b32156550a0..5e669f5b7406 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopedFileSystemsTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Persistence.EFCore/Scoping/EFCoreScopedFileSystemsTests.cs
@@ -26,8 +26,8 @@ internal sealed class EFCoreScopedFileSystemsTests : UmbracoIntegrationTest
 
     private IHostingEnvironment HostingEnvironment => GetRequiredService<IHostingEnvironment>();
 
-    private IEFCoreScopeProvider<TestUmbracoDbContext> EfCoreScopeProvider => GetRequiredService<IEFCoreScopeProvider<TestUmbracoDbContext>>();
-    private IEFCoreScopeAccessor<TestUmbracoDbContext> EfCoreScopeAccessor => GetRequiredService<IEFCoreScopeAccessor<TestUmbracoDbContext>>();
+    private IEFCoreScopeProvider<TestUmbracoDbContext> EFCoreScopeProvider => GetRequiredService<IEFCoreScopeProvider<TestUmbracoDbContext>>();
+    private IEFCoreScopeAccessor<TestUmbracoDbContext> EFCoreScopeAccessor => GetRequiredService<IEFCoreScopeAccessor<TestUmbracoDbContext>>();
 
     private void ClearFiles(IIOHelper ioHelper)
     {
@@ -46,7 +46,7 @@ public void MediaFileManager_Does_Not_Write_To_Physical_File_System_When_Scoped_
 
         Assert.IsFalse(physMediaFileSystem.FileExists("f1.txt"));
 
-        using (EfCoreScopeProvider.CreateScope(scopeFileSystems: true))
+        using (EFCoreScopeProvider.CreateScope(scopeFileSystems: true))
         {
             using (var ms = new MemoryStream("foo"u8.ToArray()))
             {
@@ -72,7 +72,7 @@ public void MediaFileManager_Writes_To_Physical_File_System_When_Scoped_And_Scop
 
         Assert.IsFalse(physMediaFileSystem.FileExists("f1.txt"));
 
-        using (var scope = EfCoreScopeProvider.CreateScope(scopeFileSystems: true))
+        using (var scope = EFCoreScopeProvider.CreateScope(scopeFileSystems: true))
         {
             using (var ms = new MemoryStream("foo"u8.ToArray()))
             {
@@ -102,7 +102,7 @@ public void MultiThread()
         var mediaFileManager = MediaFileManager;
         var taskHelper = new TaskHelper(Mock.Of<ILogger<TaskHelper>>());
 
-        using (EfCoreScopeProvider.CreateScope(scopeFileSystems: true))
+        using (EFCoreScopeProvider.CreateScope(scopeFileSystems: true))
         {
             using (var ms = new MemoryStream("foo"u8.ToArray()))
             {
@@ -140,14 +140,14 @@ public void SingleShadow()
     {
         var taskHelper = new TaskHelper(Mock.Of<ILogger<TaskHelper>>());
         var isThrown = false;
-        using (EfCoreScopeProvider.CreateScope(scopeFileSystems: true))
+        using (EFCoreScopeProvider.CreateScope(scopeFileSystems: true))
         {
             // This is testing when another thread concurrently tries to create a scoped file system
             // because at the moment we don't support concurrent scoped filesystems.
             var t = taskHelper.ExecuteBackgroundTask(() =>
             {
                 // ok to create a 'normal' other scope
-                using (var other = EfCoreScopeProvider.CreateScope())
+                using (var other = EFCoreScopeProvider.CreateScope())
                 {
                     other.Complete();
                 }
@@ -156,7 +156,7 @@ public void SingleShadow()
                 // we will get a "Already shadowing." exception.
                 Assert.Throws<InvalidOperationException>(() =>
                 {
-                    using var other = EfCoreScopeProvider.CreateScope(scopeFileSystems: true);
+                    using var other = EFCoreScopeProvider.CreateScope(scopeFileSystems: true);
                 });
 
                 isThrown = true;
@@ -174,7 +174,7 @@ public void SingleShadow()
     public void SingleShadowEvenDetached()
     {
         var taskHelper = new TaskHelper(Mock.Of<ILogger<TaskHelper>>());
-        using (var scope = EfCoreScopeProvider.CreateScope(scopeFileSystems: true))
+        using (var scope = EFCoreScopeProvider.CreateScope(scopeFileSystems: true))
         {
             // This is testing when another thread concurrently tries to create a scoped file system
             // because at the moment we don't support concurrent scoped filesystems.
@@ -186,7 +186,7 @@ public void SingleShadowEvenDetached()
                 // we will get a "Already shadowing." exception.
                 Assert.Throws<InvalidOperationException>(() =>
                 {
-                    using var other = EfCoreScopeProvider.CreateDetachedScope(scopeFileSystems: true);
+                    using var other = EFCoreScopeProvider.CreateDetachedScope(scopeFileSystems: true);
                 });
 
                 return Task.CompletedTask;
@@ -195,17 +195,17 @@ public void SingleShadowEvenDetached()
             t.Wait();
         }
 
-        var detached = EfCoreScopeProvider.CreateDetachedScope(scopeFileSystems: true);
+        var detached = EFCoreScopeProvider.CreateDetachedScope(scopeFileSystems: true);
 
-        Assert.IsNull(EfCoreScopeAccessor.AmbientScope);
+        Assert.IsNull(EFCoreScopeAccessor.AmbientScope);
 
         Assert.Throws<InvalidOperationException>(() =>
         {
             // even if there is no ambient scope, there's a single shadow
-            using var other = EfCoreScopeProvider.CreateScope(scopeFileSystems: true);
+            using var other = EFCoreScopeProvider.CreateScope(scopeFileSystems: true);
         });
 
-        EfCoreScopeProvider.AttachScope(detached);
+        EFCoreScopeProvider.AttachScope(detached);
         detached.Dispose();
     }
 }
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheAncestryTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheAncestryTests.cs
index e2ab64cf00ea..8f32b426c508 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheAncestryTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/DocumentHybridCacheAncestryTests.cs
@@ -32,9 +32,9 @@ protected override void CustomTestSetup(IUmbracoBuilder builder)
         builder.Services.AddUnique<IServerMessenger, ContentEventsTests.LocalServerMessenger>();
     }
 
-    public override void Setup()
+    public override async Task Setup()
     {
-        base.Setup();
+        await base.Setup();
         // Publish documents
         _subSubPage = ContentBuilder.CreateSimpleContent(ContentType, "_subSubPage", Subpage.Id);
         _subSubPage.Key = Guid.Parse("E4C369B5-CCCA-4981-ADAC-389824CF6B0B");
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MediaCacheServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MediaCacheServiceTests.cs
index 54d3299b0801..51d50510bd6f 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MediaCacheServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MediaCacheServiceTests.cs
@@ -44,9 +44,9 @@ protected override void CustomTestSetup(IUmbracoBuilder builder)
 
     private IMedia MediaItem { get; set; }
 
-    public override void CreateTestData()
+    public override async Task CreateTestDataAsync()
     {
-        base.CreateTestData();
+        await base.CreateTestDataAsync();
 
         MediaType = MediaTypeService.Get("image")!;
 
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MemberCacheServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MemberCacheServiceTests.cs
index e80f264c26be..316a5f306dc9 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MemberCacheServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.PublishedCache.HybridCache/MemberCacheServiceTests.cs
@@ -44,9 +44,9 @@ protected override void CustomTestSetup(IUmbracoBuilder builder)
 
     private IMember Member { get; set; }
 
-    public override void CreateTestData()
+    public override async Task CreateTestDataAsync()
     {
-        base.CreateTestData();
+        await base.CreateTestDataAsync();
 
         // Create and Save Member "MemberItem" based on "Member" member type
         MemberType = MemberTypeService.Get("Member")!;
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj b/tests/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj
index 8f96db2e624c..c28085646a15 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Tests.Integration.csproj
@@ -396,5 +396,8 @@
     <Compile Update="Umbraco.Core\Services\ElementServiceTests.SchedulePublish.cs">
       <DependentUpon>ElementServiceTests.cs</DependentUpon>
     </Compile>
+    <Compile Update="Umbraco.Core\Services\ContentTypeEditingServiceTests.ChangeTypes.cs">
+      <DependentUpon>ContentTypeEditingServiceTests.cs</DependentUpon>
+    </Compile>
   </ItemGroup>
 </Project>
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Web.BackOffice/UrlAndDomains/DomainAndUrlsTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Web.BackOffice/UrlAndDomains/DomainAndUrlsTests.cs
index 09c8aa605cc4..8ccbad537740 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Web.BackOffice/UrlAndDomains/DomainAndUrlsTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Web.BackOffice/UrlAndDomains/DomainAndUrlsTests.cs
@@ -7,7 +7,6 @@
 using Umbraco.Cms.Core.Models.PublishedContent;
 using Umbraco.Cms.Core.Notifications;
 using Umbraco.Cms.Core.Packaging;
-using Umbraco.Cms.Core.PublishedCache;
 using Umbraco.Cms.Core.Routing;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Services.Navigation;
@@ -296,38 +295,6 @@ public async Task Can_Set_Default_Culture()
         Assert.AreEqual("*" + Root.Id, domain.DomainName);
     }
 
-    [Test]
-    public void Can_Use_Obsolete_Save()
-    {
-        foreach (var culture in Cultures)
-        {
-            SetDomainOnContent(Root, culture, GetDomainUrlFromCultureCode(culture));
-        }
-
-        var domains = GetRequiredService<IDomainService>().GetAssignedDomains(Root.Id, true);
-        Assert.AreEqual(3, domains.Count());
-    }
-
-    [Test]
-    public void Can_Use_Obsolete_Delete()
-    {
-        foreach (var culture in Cultures)
-        {
-            SetDomainOnContent(Root, culture, GetDomainUrlFromCultureCode(culture));
-        }
-
-        var domainService = GetRequiredService<IDomainService>();
-
-        var domains = domainService.GetAssignedDomains(Root.Id, true);
-        Assert.AreEqual(3, domains.Count());
-
-        var result = domainService.Delete(domains.First());
-        Assert.IsTrue(result.Success);
-
-        domains = domainService.GetAssignedDomains(Root.Id, true);
-        Assert.AreEqual(2, domains.Count());
-    }
-
     [TestCase("/domain")]
     [TestCase("/")]
     [TestCase("some.domain.com")]
@@ -394,14 +361,6 @@ public async Task Cannot_Assign_Already_Used_Domains()
     private static string GetDomainUrlFromCultureCode(string culture) =>
         "/" + culture.Replace("-", string.Empty).ToLower() + "/";
 
-    private void SetDomainOnContent(IContent content, string cultureIsoCode, string domain)
-    {
-        var domainService = GetRequiredService<IDomainService>();
-        var langId = GetRequiredService<ILocalizationService>().GetLanguageIdByIsoCode(cultureIsoCode);
-        domainService.Save(
-            new UmbracoDomain(domain) { RootContentId = content.Id, LanguageId = langId });
-    }
-
     private IEnumerable<UrlInfo> GetContentUrlsAsync(IContent root) =>
         root.GetContentUrlsAsync(
             GetRequiredService<IPublishedRouter>(),
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Common/DependencyInjection/HideBackOfficeTokensHandlerTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Common/DependencyInjection/HideBackOfficeTokensHandlerTests.cs
index 8c71efed23de..35793bb43ec1 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Common/DependencyInjection/HideBackOfficeTokensHandlerTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Common/DependencyInjection/HideBackOfficeTokensHandlerTests.cs
@@ -1,7 +1,10 @@
 using System.Diagnostics.CodeAnalysis;
+using System.Security.Cryptography;
 using Microsoft.AspNetCore.DataProtection;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Features;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.Extensions.Options;
 using Moq;
 using NUnit.Framework;
@@ -36,12 +39,13 @@ private class TestSetup
         public HideBackOfficeTokensHandler Sut => field ??= new HideBackOfficeTokensHandler(
             HttpContextAccessor.Object,
             DataProtectionProvider.Object,
+            NullLogger<HideBackOfficeTokensHandler>.Instance,
             Options.Create(BackOfficeTokenCookieSettings),
             Options.Create(GlobalSettings));
 
         public Mock<IHttpContextAccessor> HttpContextAccessor { get; } = new();
 
-        private Mock<IDataProtectionProvider> DataProtectionProvider { get; } = new();
+        public Mock<IDataProtectionProvider> DataProtectionProvider { get; } = new();
 
         public Mock<IDataProtector> DataProtector { get; } = new();
 
@@ -774,6 +778,86 @@ public void Logout_CookiePrefix(bool useHttps, bool isHttps, bool expectSecurePr
 
     #endregion
 
+    #region Decryption Failure Tests
+
+    [Test]
+    public async Task HandleAsync_ProcessAuthentication_DecryptionFailure_DoesNotRestoreToken()
+    {
+        // Arrange
+        var setup = new TestSetup();
+        setup.GlobalSettings.UseHttps = false;
+        var encryptedToken = setup.EncryptValue(AccessTokenValue);
+        setup.SetupHttpContext(isHttps: false, requestCookies: new Dictionary<string, string> { { AccessTokenCookieName, encryptedToken } });
+
+        // Make the protector throw on unprotect (simulating changed data protection keys)
+        setup.DataProtector.Setup(p => p.Unprotect(It.IsAny<byte[]>()))
+            .Throws(new CryptographicException("The payload was invalid."));
+
+        var context = CreateProcessAuthenticationContext(RedactedTokenValue);
+
+        // Act
+        await setup.Sut.HandleAsync(context);
+
+        // Assert - token should remain redacted (not restored), triggering a 401
+        Assert.AreEqual(RedactedTokenValue, context.AccessToken);
+        Assert.IsTrue(setup.DeletedCookies.Contains(AccessTokenCookieName));
+    }
+
+    [Test]
+    public async Task HandleAsync_ExtractTokenRequest_DecryptionFailure_NullsPkceCodeAndRefreshToken()
+    {
+        // Arrange
+        var setup = new TestSetup();
+        setup.GlobalSettings.UseHttps = false;
+        var encryptedCode = setup.EncryptValue(PkceCodeValue);
+        var encryptedToken = setup.EncryptValue(RefreshTokenValue);
+        setup.SetupHttpContext(isHttps: false, requestCookies: new Dictionary<string, string>
+        {
+            { PkceCodeCookieName, encryptedCode },
+            { RefreshTokenCookieName, encryptedToken },
+        });
+
+        // Make the protector throw on unprotect (simulating changed data protection keys)
+        setup.DataProtector.Setup(p => p.Unprotect(It.IsAny<byte[]>()))
+            .Throws(new CryptographicException("The payload was invalid."));
+
+        var context = CreateExtractTokenRequestContext(Constants.OAuthClientIds.BackOffice, RedactedTokenValue, RedactedTokenValue);
+
+        // Act
+        await setup.Sut.HandleAsync(context);
+
+        // Assert - both should be nulled since cookies couldn't be decrypted
+        Assert.IsNull(context.Request.Code);
+        Assert.IsNull(context.Request.RefreshToken);
+        Assert.IsTrue(setup.DeletedCookies.Contains(PkceCodeCookieName));
+        Assert.IsTrue(setup.DeletedCookies.Contains(RefreshTokenCookieName));
+    }
+
+    [Test]
+    public async Task HandleAsync_ExtractRevocationRequest_DecryptionFailure_NullsToken()
+    {
+        // Arrange
+        var setup = new TestSetup();
+        setup.GlobalSettings.UseHttps = false;
+        var encryptedToken = setup.EncryptValue(AccessTokenValue);
+        setup.SetupHttpContext(isHttps: false, requestCookies: new Dictionary<string, string> { { AccessTokenCookieName, encryptedToken } });
+
+        // Make the protector throw on unprotect (simulating changed data protection keys)
+        setup.DataProtector.Setup(p => p.Unprotect(It.IsAny<byte[]>()))
+            .Throws(new CryptographicException("The payload was invalid."));
+
+        var context = CreateExtractRevocationRequestContext(Constants.OAuthClientIds.BackOffice, RedactedTokenValue, "access_token");
+
+        // Act
+        await setup.Sut.HandleAsync(context);
+
+        // Assert - token should be nulled since cookie couldn't be decrypted
+        Assert.IsNull(context.Request.Token);
+        Assert.IsTrue(setup.DeletedCookies.Contains(AccessTokenCookieName));
+    }
+
+    #endregion
+
     #region Context Factory Methods
 
     private static OpenIddictServerEvents.ApplyTokenResponseContext CreateApplyTokenResponseContext(
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Factories/IndexPresentationFactoryTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Factories/IndexPresentationFactoryTests.cs
index 9bb0d1443b65..3521decfd021 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Factories/IndexPresentationFactoryTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Factories/IndexPresentationFactoryTests.cs
@@ -62,4 +62,138 @@ public async Task Create_Should_Set_HealthStatusMessage_On_Diagnostics_Failure()
         // assert
         Assert.AreEqual(indexDiagnosticsFailureMessage, responseModel.HealthStatus.Message);
     }
+
+    [Test]
+    public async Task Create_Should_Set_UniqueKeyFieldName_For_UmbracoIndex()
+    {
+        var expectedFieldName = "__Key";
+
+        // arrange
+        var indexMock = new Mock<IUmbracoIndex>();
+        indexMock
+            .SetupGet(index => index.Name)
+            .Returns("testIndex");
+        indexMock
+            .As<IIndex>()
+            .SetupGet(index => index.Searcher)
+            .Returns(Mock.Of<ISearcher>());
+        indexMock
+            .SetupGet(index => index.UniqueKeyFieldName)
+            .Returns(expectedFieldName);
+
+        var indexDiagnosticsMock = new Mock<IIndexDiagnostics>();
+        indexDiagnosticsMock
+            .Setup(diagnostic => diagnostic.IsHealthy())
+            .Returns(Attempt<string?>.Succeed());
+        indexDiagnosticsMock
+            .SetupGet(diagnostic => diagnostic.Metadata)
+            .Returns(ReadOnlyDictionary<string, object?>.Empty);
+        indexDiagnosticsMock
+            .Setup(diagnostic => diagnostic.GetFieldNames())
+            .Returns(Enumerable.Empty<string>());
+
+        var indexDiagnosticsFactoryMock = new Mock<IIndexDiagnosticsFactory>();
+        indexDiagnosticsFactoryMock
+            .Setup(f => f.Create(It.IsAny<IIndex>()))
+            .Returns(indexDiagnosticsMock.Object);
+
+        var indexRebuilderServiceMock = new Mock<IIndexingRebuilderService>();
+        indexRebuilderServiceMock
+            .Setup(rebuilder => rebuilder.IsRebuildingAsync(It.IsAny<string>()))
+            .ReturnsAsync(false);
+
+        var factory = new IndexPresentationFactory(
+            indexDiagnosticsFactoryMock.Object,
+            new Mock<IIndexRebuilder>().Object,
+            indexRebuilderServiceMock.Object,
+            Mock.Of<ILogger<IndexPresentationFactory>>());
+
+        // act
+        var responseModel = await factory.CreateAsync(indexMock.Object);
+
+        // assert
+        Assert.AreEqual(expectedFieldName, responseModel.UniqueKeyFieldName);
+    }
+
+    [Test]
+    public async Task Create_Should_Set_UniqueKeyFieldName_Null_For_NonUmbracoIndex()
+    {
+        // arrange
+        var indexMock = new Mock<IIndex>();
+        indexMock
+            .SetupGet(index => index.Name)
+            .Returns("testIndex");
+        indexMock
+            .SetupGet(index => index.Searcher)
+            .Returns(Mock.Of<ISearcher>());
+
+        var indexDiagnosticsMock = new Mock<IIndexDiagnostics>();
+        indexDiagnosticsMock
+            .Setup(diagnostic => diagnostic.IsHealthy())
+            .Returns(Attempt<string?>.Succeed());
+        indexDiagnosticsMock
+            .SetupGet(diagnostic => diagnostic.Metadata)
+            .Returns(ReadOnlyDictionary<string, object?>.Empty);
+        indexDiagnosticsMock
+            .Setup(diagnostic => diagnostic.GetFieldNames())
+            .Returns(Enumerable.Empty<string>());
+
+        var indexDiagnosticsFactoryMock = new Mock<IIndexDiagnosticsFactory>();
+        indexDiagnosticsFactoryMock
+            .Setup(f => f.Create(It.IsAny<IIndex>()))
+            .Returns(indexDiagnosticsMock.Object);
+
+        var indexRebuilderServiceMock = new Mock<IIndexingRebuilderService>();
+        indexRebuilderServiceMock
+            .Setup(rebuilder => rebuilder.IsRebuildingAsync(It.IsAny<string>()))
+            .ReturnsAsync(false);
+
+        var factory = new IndexPresentationFactory(
+            indexDiagnosticsFactoryMock.Object,
+            new Mock<IIndexRebuilder>().Object,
+            indexRebuilderServiceMock.Object,
+            Mock.Of<ILogger<IndexPresentationFactory>>());
+
+        // act
+        var responseModel = await factory.CreateAsync(indexMock.Object);
+
+        // assert
+        Assert.IsNull(responseModel.UniqueKeyFieldName);
+    }
+
+    [Test]
+    public async Task Create_Should_Set_UniqueKeyFieldName_When_Rebuilding()
+    {
+        var expectedFieldName = "itemId";
+
+        // arrange
+        var indexMock = new Mock<IUmbracoIndex>();
+        indexMock
+            .SetupGet(index => index.Name)
+            .Returns("testIndex");
+        indexMock
+            .As<IIndex>()
+            .SetupGet(index => index.Searcher)
+            .Returns(Mock.Of<ISearcher>());
+        indexMock
+            .SetupGet(index => index.UniqueKeyFieldName)
+            .Returns(expectedFieldName);
+
+        var indexRebuilderServiceMock = new Mock<IIndexingRebuilderService>();
+        indexRebuilderServiceMock
+            .Setup(rebuilder => rebuilder.IsRebuildingAsync(It.IsAny<string>()))
+            .ReturnsAsync(true);
+
+        var factory = new IndexPresentationFactory(
+            new Mock<IIndexDiagnosticsFactory>().Object,
+            new Mock<IIndexRebuilder>().Object,
+            indexRebuilderServiceMock.Object,
+            Mock.Of<ILogger<IndexPresentationFactory>>());
+
+        // act
+        var responseModel = await factory.CreateAsync(indexMock.Object);
+
+        // assert
+        Assert.AreEqual(expectedFieldName, responseModel.UniqueKeyFieldName);
+    }
 }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Security/UriProviderTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Security/UriProviderTests.cs
new file mode 100644
index 000000000000..c716733a8fd9
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Security/UriProviderTests.cs
@@ -0,0 +1,116 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using Microsoft.AspNetCore.Http;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Api.Management.Security;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Hosting;
+using Umbraco.Cms.Core.Models.Membership;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Cms.Api.Management.Security;
+
+[TestFixture]
+public class UriProviderTests
+{
+    private Mock<ICoreBackOfficeUserManager> _userManager = null!;
+    private Mock<IHostingEnvironment> _hostingEnvironment = null!;
+    private Mock<IHttpContextAccessor> _httpContextAccessor = null!;
+    private Mock<IUser> _user = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _userManager = new Mock<ICoreBackOfficeUserManager>();
+        _hostingEnvironment = new Mock<IHostingEnvironment>();
+        _httpContextAccessor = new Mock<IHttpContextAccessor>();
+        _httpContextAccessor.Setup(a => a.HttpContext).Returns(new DefaultHttpContext());
+        _user = new Mock<IUser>();
+        _user.Setup(u => u.Key).Returns(Guid.NewGuid());
+    }
+
+    [Test]
+    public async Task ForgotPasswordUri_WithApplicationMainUrl_ReturnsAbsoluteUri()
+    {
+        var appUrl = new Uri("https://my-site.com");
+        _hostingEnvironment.Setup(h => h.ApplicationMainUrl).Returns(appUrl);
+        _userManager
+            .Setup(m => m.GeneratePasswordResetTokenAsync(It.IsAny<IUser>()))
+            .ReturnsAsync(Attempt.SucceedWithStatus(UserOperationStatus.Success, "test-token"));
+
+        var sut = new ForgotPasswordUriProvider(
+            _userManager.Object,
+            _hostingEnvironment.Object,
+            _httpContextAccessor.Object);
+
+        Attempt<Uri, UserOperationStatus> result = await sut.CreateForgotPasswordUriAsync(_user.Object);
+
+        Assert.IsTrue(result.Success);
+        Assert.IsTrue(result.Result.IsAbsoluteUri);
+        Assert.AreEqual("https", result.Result.Scheme);
+        Assert.AreEqual("my-site.com", result.Result.Host);
+        Assert.That(result.Result.AbsolutePath, Does.StartWith("/umbraco/login"));
+        Assert.That(result.Result.Query, Does.Contain("flow=reset-password"));
+    }
+
+    [Test]
+    public async Task ForgotPasswordUri_WithoutApplicationMainUrl_FailsWithApplicationUrlNotConfigured()
+    {
+        _hostingEnvironment.Setup(h => h.ApplicationMainUrl).Returns((Uri?)null);
+
+        var sut = new ForgotPasswordUriProvider(
+            _userManager.Object,
+            _hostingEnvironment.Object,
+            _httpContextAccessor.Object);
+
+        Attempt<Uri, UserOperationStatus> result = await sut.CreateForgotPasswordUriAsync(_user.Object);
+
+        Assert.IsFalse(result.Success);
+        Assert.AreEqual(UserOperationStatus.ApplicationUrlNotConfigured, result.Status);
+        _userManager.Verify(m => m.GeneratePasswordResetTokenAsync(It.IsAny<IUser>()), Times.Never());
+    }
+
+    [Test]
+    public async Task InviteUri_WithApplicationMainUrl_ReturnsAbsoluteUri()
+    {
+        var appUrl = new Uri("https://my-site.com");
+        _hostingEnvironment.Setup(h => h.ApplicationMainUrl).Returns(appUrl);
+        _userManager
+            .Setup(m => m.GenerateEmailConfirmationTokenAsync(It.IsAny<IUser>()))
+            .ReturnsAsync(Attempt.SucceedWithStatus(UserOperationStatus.Success, "test-token"));
+
+        var sut = new InviteUriProvider(
+            _userManager.Object,
+            _httpContextAccessor.Object,
+            _hostingEnvironment.Object);
+
+        Attempt<Uri, UserOperationStatus> result = await sut.CreateInviteUriAsync(_user.Object);
+
+        Assert.IsTrue(result.Success);
+        Assert.IsTrue(result.Result.IsAbsoluteUri);
+        Assert.AreEqual("https", result.Result.Scheme);
+        Assert.AreEqual("my-site.com", result.Result.Host);
+        Assert.That(result.Result.AbsolutePath, Does.StartWith("/umbraco/login"));
+        Assert.That(result.Result.Query, Does.Contain("flow=invite-user"));
+    }
+
+    [Test]
+    public async Task InviteUri_WithoutApplicationMainUrl_FailsWithApplicationUrlNotConfigured()
+    {
+        _hostingEnvironment.Setup(h => h.ApplicationMainUrl).Returns((Uri?)null);
+
+        var sut = new InviteUriProvider(
+            _userManager.Object,
+            _httpContextAccessor.Object,
+            _hostingEnvironment.Object);
+
+        Attempt<Uri, UserOperationStatus> result = await sut.CreateInviteUriAsync(_user.Object);
+
+        Assert.IsFalse(result.Success);
+        Assert.AreEqual(UserOperationStatus.ApplicationUrlNotConfigured, result.Status);
+        _userManager.Verify(m => m.GenerateEmailConfirmationTokenAsync(It.IsAny<IUser>()), Times.Never());
+    }
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasDocumentScheduleFlagProviderTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasDocumentScheduleFlagProviderTests.cs
new file mode 100644
index 000000000000..cef31f66d581
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasDocumentScheduleFlagProviderTests.cs
@@ -0,0 +1,273 @@
+
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Api.Management.Services.Flags;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Api.Management.ViewModels.Document.Collection;
+using Umbraco.Cms.Api.Management.ViewModels.Document.Item;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Cms.Api.Management.Services.Flags;
+
+[TestFixture]
+internal class HasDocumentScheduleFlagProviderTests
+{
+    private Mock<IContentService> _contentServiceMock = null!;
+    private TimeProvider _timeProvider = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _contentServiceMock = new Mock<IContentService>();
+        _timeProvider = TimeProvider.System;
+    }
+
+    [Test]
+    public void Can_Provide_Document_Tree_Flags()
+    {
+        var sut = CreateSut();
+        Assert.IsTrue(sut.CanProvideFlags<DocumentTreeItemResponseModel>());
+    }
+
+    [Test]
+    public void Can_Provide_Document_Collection_Flags()
+    {
+        var sut = CreateSut();
+        Assert.IsTrue(sut.CanProvideFlags<DocumentCollectionResponseModel>());
+    }
+
+    [Test]
+    public void Can_Provide_Document_Item_Flags()
+    {
+        var sut = CreateSut();
+        Assert.IsTrue(sut.CanProvideFlags<DocumentItemResponseModel>());
+    }
+
+    [Test]
+    public void Cannot_Provide_Element_Flags()
+    {
+        var sut = CreateSut();
+        Assert.IsFalse(sut.CanProvideFlags<ElementTreeItemResponseModel>());
+    }
+
+    [Test]
+    public async Task Should_Populate_Document_Tree_Flags()
+    {
+        Guid key1 = Guid.NewGuid();
+        Guid key2 = Guid.NewGuid();
+
+        SetupBatchScheduleMock(new Dictionary<Guid, IEnumerable<ContentSchedule>>
+        {
+            [key1] =
+            [
+                new ContentSchedule("en-EN", DateTime.Now.AddDays(1), ContentScheduleAction.Release),
+                new ContentSchedule("da-DA", DateTime.Now.AddDays(-1), ContentScheduleAction.Release),
+            ],
+            [key2] =
+            [
+                new ContentSchedule("*", DateTime.Now.AddDays(1), ContentScheduleAction.Release),
+            ],
+        });
+
+        var sut = CreateSut();
+
+        var variant1 = new DocumentVariantItemResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "en-EN",
+        };
+        var variant2 = new DocumentVariantItemResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "da-DA",
+        };
+        var variant3 = new DocumentVariantItemResponseModel
+        {
+            State = DocumentVariantState.PublishedPendingChanges,
+            Name = "Test",
+        };
+
+        var viewModels = new List<DocumentTreeItemResponseModel>
+        {
+            new() { Id = key1, Variants = [variant1, variant2] },
+            new() { Id = key2, Variants = [variant3] },
+        };
+
+        await sut.PopulateFlagsAsync(viewModels);
+
+        Assert.AreEqual(0, viewModels[0].Variants.First(x => x.Culture == "da-DA").Flags.Count());
+        Assert.AreEqual(1, viewModels[0].Variants.First(x => x.Culture == "en-EN").Flags.Count());
+        Assert.AreEqual(1, viewModels[1].Variants.First().Flags.Count());
+
+        var flagModel = viewModels[0].Variants.First(x => x.Culture == "en-EN").Flags.First();
+        Assert.AreEqual("Umb.ScheduledForPublish", flagModel.Alias);
+    }
+
+    [Test]
+    public async Task Should_Populate_Document_Collection_Flags()
+    {
+        Guid key1 = Guid.NewGuid();
+        Guid key2 = Guid.NewGuid();
+
+        SetupBatchScheduleMock(new Dictionary<Guid, IEnumerable<ContentSchedule>>
+        {
+            [key1] =
+            [
+                new ContentSchedule("en-EN", DateTime.Now.AddDays(1), ContentScheduleAction.Release),
+                new ContentSchedule("da-DA", DateTime.Now.AddDays(-1), ContentScheduleAction.Release),
+            ],
+            [key2] =
+            [
+                new ContentSchedule("*", DateTime.Now.AddDays(1), ContentScheduleAction.Release),
+            ],
+        });
+
+        var sut = CreateSut();
+
+        var variant1 = new DocumentVariantResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "en-EN",
+        };
+        var variant2 = new DocumentVariantResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "da-DA",
+        };
+        var variant3 = new DocumentVariantResponseModel
+        {
+            State = DocumentVariantState.PublishedPendingChanges,
+            Name = "Test",
+        };
+
+        var viewModels = new List<DocumentCollectionResponseModel>
+        {
+            new()
+            {
+                Id = key1,
+                Variants = [variant1, variant2],
+            },
+            new()
+            {
+                Id = key2,
+                Variants = [variant3],
+            },
+        };
+
+        await sut.PopulateFlagsAsync(viewModels);
+
+        Assert.AreEqual(0, viewModels[0].Variants.First(x => x.Culture == "da-DA").Flags.Count());
+        Assert.AreEqual(1, viewModels[0].Variants.First(x => x.Culture == "en-EN").Flags.Count());
+        Assert.AreEqual(1, viewModels[1].Variants.First().Flags.Count());
+
+        var flagModel = viewModels[0].Variants.First(x => x.Culture == "en-EN").Flags.First();
+        Assert.AreEqual("Umb.ScheduledForPublish", flagModel.Alias);
+    }
+
+    [Test]
+    public async Task Should_Populate_Document_Item_Flags()
+    {
+        Guid key1 = Guid.NewGuid();
+        Guid key2 = Guid.NewGuid();
+
+        SetupBatchScheduleMock(new Dictionary<Guid, IEnumerable<ContentSchedule>>
+        {
+            [key1] =
+            [
+                new ContentSchedule("en-EN", DateTime.Now.AddDays(1), ContentScheduleAction.Release),
+                new ContentSchedule("da-DA", DateTime.Now.AddDays(-1), ContentScheduleAction.Release),
+            ],
+            [key2] =
+            [
+                new ContentSchedule("*", DateTime.Now.AddDays(1), ContentScheduleAction.Release),
+            ],
+        });
+
+        var sut = CreateSut();
+
+        var variant1 = new DocumentVariantItemResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "en-EN",
+        };
+        var variant2 = new DocumentVariantItemResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "da-DA",
+        };
+        var variant3 = new DocumentVariantItemResponseModel
+        {
+            State = DocumentVariantState.PublishedPendingChanges,
+            Name = "Test",
+        };
+
+        var viewModels = new List<DocumentItemResponseModel>
+        {
+            new() { Id = key1, Variants = [variant1, variant2] },
+            new() { Id = key2, Variants = [variant3] },
+        };
+
+        await sut.PopulateFlagsAsync(viewModels);
+
+        Assert.AreEqual(0, viewModels[0].Variants.First(x => x.Culture == "da-DA").Flags.Count());
+        Assert.AreEqual(1, viewModels[0].Variants.First(x => x.Culture == "en-EN").Flags.Count());
+        Assert.AreEqual(1, viewModels[1].Variants.First().Flags.Count());
+
+        var flagModel = viewModels[0].Variants.First(x => x.Culture == "en-EN").Flags.First();
+        Assert.AreEqual("Umb.ScheduledForPublish", flagModel.Alias);
+    }
+
+    [Test]
+    public async Task Should_Use_Batch_Schedule_Retrieval()
+    {
+        Guid key1 = Guid.NewGuid();
+        Guid key2 = Guid.NewGuid();
+
+        SetupBatchScheduleMock(new Dictionary<Guid, IEnumerable<ContentSchedule>>());
+
+        var sut = CreateSut();
+
+        var viewModels = new List<DocumentTreeItemResponseModel>
+        {
+            new() { Id = key1, Variants = [new DocumentVariantItemResponseModel { State = DocumentVariantState.Published, Name = "Test1" }] },
+            new() { Id = key2, Variants = [new DocumentVariantItemResponseModel { State = DocumentVariantState.Published, Name = "Test2" }] },
+        };
+
+        await sut.PopulateFlagsAsync(viewModels);
+
+        _contentServiceMock.Verify(
+            x => x.GetContentSchedulesByKeys(It.Is<Guid[]>(k => k.Length == 2 && k.Contains(key1) && k.Contains(key2))),
+            Times.Once);
+        _contentServiceMock.Verify(
+            x => x.GetContentScheduleByContentId(It.IsAny<Guid>()),
+            Times.Never);
+    }
+
+    private HasDocumentScheduleFlagProvider CreateSut()
+        => new(_contentServiceMock.Object, _timeProvider);
+
+    private void SetupBatchScheduleMock(IDictionary<Guid, IEnumerable<ContentSchedule>> schedules) =>
+        _contentServiceMock
+            .Setup(x => x.GetContentSchedulesByKeys(It.IsAny<Guid[]>()))
+            .Returns((Guid[] keys) =>
+            {
+                var result = new Dictionary<Guid, IEnumerable<ContentSchedule>>();
+                foreach (Guid key in keys)
+                {
+                    if (schedules.TryGetValue(key, out IEnumerable<ContentSchedule>? s))
+                    {
+                        result[key] = s;
+                    }
+                }
+
+                return result;
+            });
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasElementScheduleFlagProviderTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasElementScheduleFlagProviderTests.cs
new file mode 100644
index 000000000000..1c4850ba5102
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasElementScheduleFlagProviderTests.cs
@@ -0,0 +1,232 @@
+
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Api.Management.Services.Flags;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Api.Management.ViewModels.Element;
+using Umbraco.Cms.Api.Management.ViewModels.Element.Item;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Cms.Api.Management.Services.Flags;
+
+[TestFixture]
+internal class HasElementScheduleFlagProviderTests
+{
+    private Mock<IElementService> _elementServiceMock = null!;
+    private TimeProvider _timeProvider = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _elementServiceMock = new Mock<IElementService>();
+        _timeProvider = TimeProvider.System;
+    }
+
+    [Test]
+    public void Can_Provide_Element_Tree_Flags()
+    {
+        var sut = CreateSut();
+        Assert.IsTrue(sut.CanProvideFlags<ElementTreeItemResponseModel>());
+    }
+
+    [Test]
+    public void Can_Provide_Element_Item_Flags()
+    {
+        var sut = CreateSut();
+        Assert.IsTrue(sut.CanProvideFlags<ElementItemResponseModel>());
+    }
+
+    [Test]
+    public void Cannot_Provide_Document_Flags()
+    {
+        var sut = CreateSut();
+        Assert.IsFalse(sut.CanProvideFlags<DocumentTreeItemResponseModel>());
+    }
+
+    [Test]
+    public async Task Should_Populate_Element_Tree_Flags()
+    {
+        Guid key1 = Guid.NewGuid();
+        Guid key2 = Guid.NewGuid();
+
+        SetupBatchScheduleMock(new Dictionary<Guid, IEnumerable<ContentSchedule>>
+        {
+            [key1] =
+            [
+                new ContentSchedule("en-EN", DateTime.Now.AddDays(1), ContentScheduleAction.Release),
+                new ContentSchedule("da-DA", DateTime.Now.AddDays(-1), ContentScheduleAction.Release),
+            ],
+            [key2] =
+            [
+                new ContentSchedule("*", DateTime.Now.AddDays(1), ContentScheduleAction.Release),
+            ],
+        });
+
+        var sut = CreateSut();
+
+        var variant1 = new ElementVariantItemResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "en-EN",
+        };
+        var variant2 = new ElementVariantItemResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "da-DA",
+        };
+        var variant3 = new ElementVariantItemResponseModel
+        {
+            State = DocumentVariantState.PublishedPendingChanges,
+            Name = "Test",
+        };
+
+        var viewModels = new List<ElementTreeItemResponseModel>
+        {
+            new() { Id = key1, Variants = [variant1, variant2] },
+            new() { Id = key2, Variants = [variant3] },
+        };
+
+        await sut.PopulateFlagsAsync(viewModels);
+
+        Assert.AreEqual(0, viewModels[0].Variants.First(x => x.Culture == "da-DA").Flags.Count());
+        Assert.AreEqual(1, viewModels[0].Variants.First(x => x.Culture == "en-EN").Flags.Count());
+        Assert.AreEqual(1, viewModels[1].Variants.First().Flags.Count());
+
+        var flagModel = viewModels[0].Variants.First(x => x.Culture == "en-EN").Flags.First();
+        Assert.AreEqual("Umb.ScheduledForPublish", flagModel.Alias);
+    }
+
+    [Test]
+    public async Task Should_Populate_Element_Item_Flags()
+    {
+        Guid key1 = Guid.NewGuid();
+        Guid key2 = Guid.NewGuid();
+
+        SetupBatchScheduleMock(new Dictionary<Guid, IEnumerable<ContentSchedule>>
+        {
+            [key1] =
+            [
+                new ContentSchedule("en-EN", DateTime.Now.AddDays(1), ContentScheduleAction.Release),
+                new ContentSchedule("da-DA", DateTime.Now.AddDays(-1), ContentScheduleAction.Release),
+            ],
+            [key2] =
+            [
+                new ContentSchedule("*", DateTime.Now.AddDays(1), ContentScheduleAction.Release),
+            ],
+        });
+
+        var sut = CreateSut();
+
+        var variant1 = new ElementVariantItemResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "en-EN",
+        };
+        var variant2 = new ElementVariantItemResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "da-DA",
+        };
+        var variant3 = new ElementVariantItemResponseModel
+        {
+            State = DocumentVariantState.PublishedPendingChanges,
+            Name = "Test",
+        };
+
+        var viewModels = new List<ElementItemResponseModel>
+        {
+            new() { Id = key1, Variants = [variant1, variant2] },
+            new() { Id = key2, Variants = [variant3] },
+        };
+
+        await sut.PopulateFlagsAsync(viewModels);
+
+        Assert.AreEqual(0, viewModels[0].Variants.First(x => x.Culture == "da-DA").Flags.Count());
+        Assert.AreEqual(1, viewModels[0].Variants.First(x => x.Culture == "en-EN").Flags.Count());
+        Assert.AreEqual(1, viewModels[1].Variants.First().Flags.Count());
+
+        var flagModel = viewModels[0].Variants.First(x => x.Culture == "en-EN").Flags.First();
+        Assert.AreEqual("Umb.ScheduledForPublish", flagModel.Alias);
+    }
+
+    [Test]
+    public async Task Should_Not_Populate_Flags_When_No_Schedules()
+    {
+        Guid key1 = Guid.NewGuid();
+
+        SetupBatchScheduleMock(new Dictionary<Guid, IEnumerable<ContentSchedule>>
+        {
+            [key1] = [],
+        });
+
+        var sut = CreateSut();
+
+        var variant1 = new ElementVariantItemResponseModel
+        {
+            State = DocumentVariantState.Published,
+            Name = "Test1",
+            Culture = "en-EN",
+        };
+
+        var viewModels = new List<ElementTreeItemResponseModel>
+        {
+            new() { Id = key1, Variants = [variant1] },
+        };
+
+        await sut.PopulateFlagsAsync(viewModels);
+
+        Assert.AreEqual(0, viewModels[0].Variants.First().Flags.Count());
+    }
+
+    [Test]
+    public async Task Should_Use_Batch_Schedule_Retrieval()
+    {
+        Guid key1 = Guid.NewGuid();
+        Guid key2 = Guid.NewGuid();
+
+        SetupBatchScheduleMock(new Dictionary<Guid, IEnumerable<ContentSchedule>>());
+
+        var sut = CreateSut();
+
+        var viewModels = new List<ElementTreeItemResponseModel>
+        {
+            new() { Id = key1, Variants = [new ElementVariantItemResponseModel { State = DocumentVariantState.Published, Name = "Test1" }] },
+            new() { Id = key2, Variants = [new ElementVariantItemResponseModel { State = DocumentVariantState.Published, Name = "Test2" }] },
+        };
+
+        await sut.PopulateFlagsAsync(viewModels);
+
+        _elementServiceMock.Verify(
+            x => x.GetContentSchedulesByKeys(It.Is<Guid[]>(k => k.Length == 2 && k.Contains(key1) && k.Contains(key2))),
+            Times.Once);
+        _elementServiceMock.Verify(
+            x => x.GetContentScheduleByContentId(It.IsAny<Guid>()),
+            Times.Never);
+    }
+
+    private HasElementScheduleFlagProvider CreateSut()
+        => new(_elementServiceMock.Object, _timeProvider);
+
+    private void SetupBatchScheduleMock(IDictionary<Guid, IEnumerable<ContentSchedule>> schedules) =>
+        _elementServiceMock
+            .Setup(x => x.GetContentSchedulesByKeys(It.IsAny<Guid[]>()))
+            .Returns((Guid[] keys) =>
+            {
+                var result = new Dictionary<Guid, IEnumerable<ContentSchedule>>();
+                foreach (Guid key in keys)
+                {
+                    if (schedules.TryGetValue(key, out IEnumerable<ContentSchedule>? s))
+                    {
+                        result[key] = s;
+                    }
+                }
+
+                return result;
+            });
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasPendingChangesFlagProviderTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasPendingChangesFlagProviderTests.cs
index 480da73b954a..22574f025138 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasPendingChangesFlagProviderTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasPendingChangesFlagProviderTests.cs
@@ -1,6 +1,7 @@
 using NUnit.Framework;
 using Umbraco.Cms.Api.Management.Services.Flags;
 using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Api.Management.ViewModels.Element;
 
 namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Cms.Api.Management.Services.Flags;
 
@@ -8,21 +9,35 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Cms.Api.Management.Services.Flags;
 internal class HasPendingChangesFlagProviderTests
 {
     [Test]
-    public void HasPendingChangesFlagProvider_Can_Provide_Variant_Item_Flags()
+    public void HasPendingChangesFlagProvider_Can_Provide_Document_Variant_Item_Flags()
     {
         var sut = new HasPendingChangesFlagProvider();
         Assert.IsTrue(sut.CanProvideFlags<DocumentVariantItemResponseModel>());
     }
 
     [Test]
-    public void HasPendingChangesFlagProvider_Can_Provide_Variant_Flags()
+    public void HasPendingChangesFlagProvider_Can_Provide_Document_Variant_Flags()
     {
         var sut = new HasPendingChangesFlagProvider();
         Assert.IsTrue(sut.CanProvideFlags<DocumentVariantResponseModel>());
     }
 
     [Test]
-    public async Task HasPendingChangesFlagProvider_Should_Populate_Variant_Item_Flags()
+    public void HasPendingChangesFlagProvider_Can_Provide_Element_Variant_Item_Flags()
+    {
+        var sut = new HasPendingChangesFlagProvider();
+        Assert.IsTrue(sut.CanProvideFlags<ElementVariantItemResponseModel>());
+    }
+
+    [Test]
+    public void HasPendingChangesFlagProvider_Can_Provide_Element_Variant_Flags()
+    {
+        var sut = new HasPendingChangesFlagProvider();
+        Assert.IsTrue(sut.CanProvideFlags<ElementVariantResponseModel>());
+    }
+
+    [Test]
+    public async Task HasPendingChangesFlagProvider_Should_Populate_Document_Variant_Item_Flags()
     {
         var sut = new HasPendingChangesFlagProvider();
 
@@ -52,7 +67,7 @@ public async Task HasPendingChangesFlagProvider_Should_Populate_Variant_Item_Fla
     }
 
     [Test]
-    public async Task HasPendingChangesFlagProvider_Should_Populate_Variant_Flags()
+    public async Task HasPendingChangesFlagProvider_Should_Populate_Document_Variant_Flags()
     {
         var sut = new HasPendingChangesFlagProvider();
 
@@ -80,4 +95,64 @@ public async Task HasPendingChangesFlagProvider_Should_Populate_Variant_Flags()
         var flagModel = variants[0].Flags.First();
         Assert.AreEqual("Umb.PendingChanges", flagModel.Alias);
     }
+
+    [Test]
+    public async Task HasPendingChangesFlagProvider_Should_Populate_Element_Variant_Item_Flags()
+    {
+        var sut = new HasPendingChangesFlagProvider();
+
+        var variants = new List<ElementVariantItemResponseModel>
+        {
+            new()
+            {
+                State = DocumentVariantState.PublishedPendingChanges,
+                Culture = null,
+                Name = "Test",
+            },
+            new()
+            {
+                State = DocumentVariantState.Published,
+                Culture = null,
+                Name = "Test2",
+            },
+        };
+
+        await sut.PopulateFlagsAsync(variants);
+
+        Assert.AreEqual(variants[0].Flags.Count(), 1);
+        Assert.AreEqual(variants[1].Flags.Count(), 0);
+
+        var flagModel = variants[0].Flags.First();
+        Assert.AreEqual("Umb.PendingChanges", flagModel.Alias);
+    }
+
+    [Test]
+    public async Task HasPendingChangesFlagProvider_Should_Populate_Element_Variant_Flags()
+    {
+        var sut = new HasPendingChangesFlagProvider();
+
+        var variants = new List<ElementVariantResponseModel>
+        {
+            new()
+            {
+                State = DocumentVariantState.PublishedPendingChanges,
+                Culture = null,
+                Name = "Test",
+            },
+            new()
+            {
+                State = DocumentVariantState.Published,
+                Culture = null,
+                Name = "Test2",
+            },
+        };
+
+        await sut.PopulateFlagsAsync(variants);
+
+        Assert.AreEqual(variants[0].Flags.Count(), 1);
+        Assert.AreEqual(variants[1].Flags.Count(), 0);
+
+        var flagModel = variants[0].Flags.First();
+        Assert.AreEqual("Umb.PendingChanges", flagModel.Alias);
+    }
 }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasScheduleFlagProviderTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasScheduleFlagProviderTests.cs
deleted file mode 100644
index 195e443b10b7..000000000000
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Cms.Api.Management/Services/Flags/HasScheduleFlagProviderTests.cs
+++ /dev/null
@@ -1,171 +0,0 @@
-using Moq;
-using NUnit.Framework;
-using Umbraco.Cms.Api.Management.Services.Flags;
-using Umbraco.Cms.Api.Management.ViewModels.Content;
-using Umbraco.Cms.Api.Management.ViewModels.Document;
-using Umbraco.Cms.Api.Management.ViewModels.Document.Collection;
-using Umbraco.Cms.Api.Management.ViewModels.Document.Item;
-using Umbraco.Cms.Api.Management.ViewModels.Tree;
-using Umbraco.Cms.Core.Models;
-using Umbraco.Cms.Core.Models.Entities;
-using Umbraco.Cms.Core.Services;
-
-namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Cms.Api.Management.Services.Flags;
-
-[TestFixture]
-internal class HasScheduleFlagProviderTests
-{
-    [Test]
-    public void HasScheduleFlagProvider_Can_Provide_Document_Tree_Flags()
-    {
-        var contentServiceMock = new Mock<IContentService>();
-
-        var sut = new HasScheduleFlagProvider(contentServiceMock.Object);
-        Assert.IsTrue(sut.CanProvideFlags<DocumentTreeItemResponseModel>());
-    }
-
-    [Test]
-    public void HasScheduleFlagProvider_Can_Provide_Document_Collection_Flags()
-    {
-        var contentServiceMock = new Mock<IContentService>();
-
-        var sut = new HasScheduleFlagProvider(contentServiceMock.Object);
-        Assert.IsTrue(sut.CanProvideFlags<DocumentCollectionResponseModel>());
-    }
-
-    [Test]
-    public void HasScheduleFlagProvider_Can_Provide_Document_Item_Flags()
-    {
-        var contentServiceMock = new Mock<IContentService>();
-
-        var sut = new HasScheduleFlagProvider(contentServiceMock.Object);
-        Assert.IsTrue(sut.CanProvideFlags<DocumentItemResponseModel>());
-    }
-
-    [Test]
-    public async Task HasScheduleFlagProvider_Should_Populate_Document_Tree_Flags()
-    {
-        var entities = new List<EntitySlim>
-        {
-            new() { Key = Guid.NewGuid(), Name = "Item 1" }, new() { Key = Guid.NewGuid(), Name = "Item 2" },
-        };
-
-        Guid[] keys = entities.Select(x => x.Key).ToArray();
-        var contentServiceMock = new Mock<IContentService>();
-        contentServiceMock
-            .Setup(x => x.GetContentSchedulesByKeys(keys))
-            .Returns(CreateContentSchedules(entities[0].Key, entities[1].Key));
-
-        var sut = new HasScheduleFlagProvider(contentServiceMock.Object);
-
-        var variant1 = new DocumentVariantItemResponseModel() { State = DocumentVariantState.Published, Name = "Test1", Culture = "en-EN" };
-        var variant2 = new DocumentVariantItemResponseModel() { State = DocumentVariantState.Published, Name = "Test1", Culture = "da-DA" };
-        var variant3 = new DocumentVariantItemResponseModel() { State = DocumentVariantState.PublishedPendingChanges, Name = "Test" };
-
-        var viewModels = new List<DocumentTreeItemResponseModel>
-        {
-            new() { Id = entities[0].Key, Variants = [variant1, variant2] }, new() { Id = entities[1].Key, Variants = [variant3] },
-        };
-
-        await sut.PopulateFlagsAsync(viewModels);
-
-        Assert.AreEqual(viewModels[0].Variants.FirstOrDefault(x => x.Culture == "da-DA").Flags.Count(), 0);
-        Assert.AreEqual(viewModels[0].Variants.FirstOrDefault(x => x.Culture == "en-EN").Flags.Count(), 1);
-        Assert.AreEqual(viewModels[1].Variants.First().Flags.Count(), 1);
-
-        var flagModel = viewModels[0].Variants.First().Flags.First();
-        Assert.AreEqual("Umb.ScheduledForPublish", flagModel.Alias);
-    }
-
-    [Test]
-    public async Task HasScheduleFlagProvider_Should_Populate_Document_Collection_Flags()
-    {
-        var entities = new List<EntitySlim>
-        {
-            new() { Key = Guid.NewGuid(), Name = "Item 1" }, new() { Key = Guid.NewGuid(), Name = "Item 2" },
-        };
-
-        Guid[] keys = entities.Select(x => x.Key).ToArray();
-        var contentServiceMock = new Mock<IContentService>();
-        contentServiceMock
-            .Setup(x => x.GetContentSchedulesByKeys(keys))
-            .Returns(CreateContentSchedules(entities[0].Key, entities[1].Key));
-
-        var sut = new HasScheduleFlagProvider(contentServiceMock.Object);
-
-        var variant1 = new DocumentVariantResponseModel() { State = DocumentVariantState.Published, Name = "Test1", Culture = "en-EN" };
-        var variant2 = new DocumentVariantResponseModel() { State = DocumentVariantState.Published, Name = "Test1", Culture = "da-DA" };
-        var variant3 = new DocumentVariantResponseModel() { State = DocumentVariantState.PublishedPendingChanges, Name = "Test" };
-
-        var viewModels = new List<DocumentCollectionResponseModel>
-        {
-            new() { Id = entities[0].Key, Variants = [variant1, variant2] }, new() { Id = entities[1].Key, Variants = [variant3] },
-        };
-
-        await sut.PopulateFlagsAsync(viewModels);
-
-        Assert.AreEqual(viewModels[0].Variants.FirstOrDefault(x => x.Culture == "da-DA").Flags.Count(), 0);
-        Assert.AreEqual(viewModels[0].Variants.FirstOrDefault(x => x.Culture == "en-EN").Flags.Count(), 1);
-        Assert.AreEqual(viewModels[1].Variants.First().Flags.Count(), 1);
-
-        var flagModel = viewModels[0].Variants.First().Flags.First();
-        Assert.AreEqual("Umb.ScheduledForPublish", flagModel.Alias);
-    }
-
-    [Test]
-    public async Task HasScheduleFlagProvider_Should_Populate_Document_Item_Flags()
-    {
-        var entities = new List<EntitySlim>
-        {
-            new() { Key = Guid.NewGuid(), Name = "Item 1" }, new() { Key = Guid.NewGuid(), Name = "Item 2" },
-        };
-
-        Guid[] keys = entities.Select(x => x.Key).ToArray();
-        var contentServiceMock = new Mock<IContentService>();
-        contentServiceMock
-            .Setup(x => x.GetContentSchedulesByKeys(keys))
-            .Returns(CreateContentSchedules(entities[0].Key, entities[1].Key));
-
-        var sut = new HasScheduleFlagProvider(contentServiceMock.Object);
-
-        var variant1 = new DocumentVariantItemResponseModel() { State = DocumentVariantState.Published, Name = "Test1", Culture = "en-EN" };
-        var variant2 = new DocumentVariantItemResponseModel() { State = DocumentVariantState.Published, Name = "Test1", Culture = "da-DA" };
-        var variant3 = new DocumentVariantItemResponseModel() { State = DocumentVariantState.PublishedPendingChanges, Name = "Test" };
-
-        var viewModels = new List<DocumentItemResponseModel>
-        {
-            new() { Id = entities[0].Key, Variants = [variant1, variant2] }, new() { Id = entities[1].Key, Variants = [variant3] },
-        };
-
-        await sut.PopulateFlagsAsync(viewModels);
-
-        Assert.AreEqual(viewModels[0].Variants.FirstOrDefault(x => x.Culture == "da-DA").Flags.Count(), 0);
-        Assert.AreEqual(viewModels[0].Variants.FirstOrDefault(x => x.Culture == "en-EN").Flags.Count(), 1);
-        Assert.AreEqual(viewModels[1].Variants.First().Flags.Count(), 1);
-
-        var flagModel = viewModels[0].Variants.First().Flags.First();
-        Assert.AreEqual("Umb.ScheduledForPublish", flagModel.Alias);
-    }
-
-    private Dictionary<Guid, IEnumerable<ContentSchedule>> CreateContentSchedules(Guid key1, Guid key2)
-    {
-        Dictionary<Guid, IEnumerable<ContentSchedule>> contentSchedules = new Dictionary<Guid, IEnumerable<ContentSchedule>>
-        {
-            {
-                key1,
-                [
-                    new ContentSchedule("en-EN", DateTime.Now.AddDays(1), ContentScheduleAction.Release), // Scheduled for release
-                    new ContentSchedule("da-DA", DateTime.Now.AddDays(-1), ContentScheduleAction.Release) // Not Scheduled for release
-                ]
-            },
-            {
-                key2,
-                [
-                    new ContentSchedule("*", DateTime.Now.AddDays(1), ContentScheduleAction.Release) // Scheduled for release
-                ]
-            },
-        };
-
-        return contentSchedules;
-    }
-}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/FullDataSetCachePolicyFindTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/FullDataSetCachePolicyFindTests.cs
new file mode 100644
index 000000000000..ce8b6eda1bc3
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/FullDataSetCachePolicyFindTests.cs
@@ -0,0 +1,341 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using System.Collections.Concurrent;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core.Cache;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Infrastructure.Scoping;
+using Umbraco.Cms.Tests.Common.Attributes;
+using IScope = Umbraco.Cms.Infrastructure.Scoping.IScope;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Cache;
+
+/// <summary>
+/// Tests for <see cref="FullDataSetRepositoryCachePolicy{TEntity,TId}.FindCached"/> and
+/// <see cref="FullDataSetRepositoryCachePolicy{TEntity,TId}.ExistsCached"/> methods.
+/// </summary>
+[TestFixture]
+public class FullDataSetCachePolicyFindTests
+{
+    private IScopeAccessor DefaultAccessor
+    {
+        get
+        {
+            var accessor = new Mock<IScopeAccessor>();
+            var scope = new Mock<IScope>();
+            scope.Setup(x => x.RepositoryCacheMode).Returns(RepositoryCacheMode.Default);
+            accessor.Setup(x => x.AmbientScope).Returns(scope.Object);
+            return accessor.Object;
+        }
+    }
+
+    private FullDataSetRepositoryCachePolicy<CloneCountingEntity, int> CreatePolicy(
+        IAppPolicyCache? cache = null,
+        bool expires = false)
+    {
+        cache ??= new NonLockingCache();
+        return new FullDataSetRepositoryCachePolicy<CloneCountingEntity, int>(
+            cache,
+            DefaultAccessor,
+            new SingleServerCacheVersionService(),
+            Mock.Of<ICacheSyncService>(),
+            item => item.Id,
+            expires);
+    }
+
+    private static CloneCountingEntity[] CreateEntities(int count)
+    {
+        var entities = new CloneCountingEntity[count];
+        for (var i = 0; i < count; i++)
+        {
+            entities[i] = new CloneCountingEntity(i + 1, $"entity-{i + 1}");
+        }
+
+        return entities;
+    }
+
+    [Test]
+    public void FindCached_Returns_Matching_Entity()
+    {
+        var entities = CreateEntities(5);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        CloneCountingEntity.ResetCloneCount();
+
+        var found = policy.FindCached(x => x.Id == 3, _ => entities);
+
+        Assert.IsNotNull(found);
+        Assert.AreEqual(3, found!.Id);
+        Assert.AreEqual("entity-3", found.Name);
+    }
+
+    [Test]
+    public void FindCached_Returns_Deep_Clone()
+    {
+        var entities = CreateEntities(3);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        var found = policy.FindCached(x => x.Id == 2, _ => entities);
+
+        Assert.IsNotNull(found);
+        Assert.AreEqual(2, found!.Id);
+
+        // Must be a different reference than the cached original.
+        var cachedOriginal = entities.First(x => x.Id == 2);
+        Assert.AreNotSame(cachedOriginal, found);
+    }
+
+    [Test]
+    public void FindCached_Returns_Null_When_No_Match()
+    {
+        var entities = CreateEntities(3);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        var found = policy.FindCached(x => x.Id == 999, _ => entities);
+
+        Assert.IsNull(found);
+    }
+
+    [Test]
+    public void FindCached_Populates_Cache_On_Miss()
+    {
+        var entities = CreateEntities(3);
+        var performGetAllCallCount = 0;
+
+        var policy = CreatePolicy();
+
+        // Cache is empty — FindCached should trigger performGetAll.
+        var found = policy.FindCached(x => x.Id == 2, _ =>
+        {
+            performGetAllCallCount++;
+            return entities;
+        });
+
+        Assert.IsNotNull(found);
+        Assert.AreEqual(2, found!.Id);
+        Assert.AreEqual(1, performGetAllCallCount, "performGetAll should be called once to populate cache");
+
+        // Second call should NOT trigger performGetAll again.
+        var found2 = policy.FindCached(x => x.Id == 1, _ =>
+        {
+            performGetAllCallCount++;
+            return entities;
+        });
+
+        Assert.IsNotNull(found2);
+        Assert.AreEqual(1, performGetAllCallCount, "performGetAll should not be called again — cache is warm");
+    }
+
+    [Test]
+    public void ExistsCached_Returns_True_For_Match()
+    {
+        var entities = CreateEntities(5);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        var exists = policy.ExistsCached(x => x.Id == 3, _ => entities);
+
+        Assert.IsTrue(exists);
+    }
+
+    [Test]
+    public void ExistsCached_Returns_False_For_No_Match()
+    {
+        var entities = CreateEntities(5);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        var exists = policy.ExistsCached(x => x.Id == 999, _ => entities);
+
+        Assert.IsFalse(exists);
+    }
+
+    [Test]
+    public void FindCached_Clones_Only_Matched_Entity()
+    {
+        const int entityCount = 50;
+        var entities = CreateEntities(entityCount);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        CloneCountingEntity.ResetCloneCount();
+
+        // FindCached should clone only the 1 matched entity.
+        var found = policy.FindCached(x => x.Id == 25, _ => entities);
+
+        Assert.IsNotNull(found);
+        Assert.AreEqual(25, found!.Id);
+        Assert.AreEqual(1, CloneCountingEntity.CloneCount, "FindCached should trigger exactly 1 DeepClone call");
+    }
+
+    [Test]
+    public void GetAll_Clones_All_Entities()
+    {
+        // Verify the baseline: GetAll clones every entity.
+        const int entityCount = 50;
+        var entities = CreateEntities(entityCount);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        CloneCountingEntity.ResetCloneCount();
+
+        // GetAll clones every entity.
+        var all = policy.GetAll(null, _ => entities);
+
+        Assert.AreEqual(entityCount, all.Length);
+        Assert.AreEqual(entityCount, CloneCountingEntity.CloneCount, "GetAll should trigger N DeepClone calls");
+    }
+
+    [Test]
+    public void ExistsCached_Does_Not_Clone()
+    {
+        const int entityCount = 50;
+        var entities = CreateEntities(entityCount);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        CloneCountingEntity.ResetCloneCount();
+
+        var exists = policy.ExistsCached(x => x.Id == 25, _ => entities);
+
+        Assert.IsTrue(exists);
+        Assert.AreEqual(0, CloneCountingEntity.CloneCount, "ExistsCached should trigger zero DeepClone calls");
+    }
+
+    [Test]
+    [LongRunning]
+    public void FindCached_Is_ThreadSafe()
+    {
+        const int threadCount = 20;
+        var threads = new Thread[threadCount];
+        var barrier = new ManualResetEventSlim(false);
+        var exceptions = new ConcurrentBag<Exception>();
+
+        var entities = CreateEntities(100);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        for (var i = 0; i < threadCount; i++)
+        {
+            var targetId = (i % 100) + 1;
+            threads[i] = new Thread(() =>
+            {
+                barrier.Wait();
+                try
+                {
+                    var result = policy.FindCached(x => x.Id == targetId, _ => entities);
+                    Assert.IsNotNull(result);
+                    Assert.AreEqual(targetId, result!.Id);
+                }
+                catch (Exception e)
+                {
+                    exceptions.Add(e);
+                }
+            });
+        }
+
+        using (ExecutionContext.SuppressFlow())
+        {
+            foreach (var t in threads)
+            {
+                t.Start();
+            }
+        }
+
+        barrier.Set();
+        foreach (var t in threads)
+        {
+            t.Join();
+        }
+
+        Assert.IsEmpty(
+            exceptions,
+            $"Thread safety violation: {string.Join(Environment.NewLine, exceptions.Select(e => e.Message))}");
+    }
+
+    [Test]
+    public void FindAllCached_Clones_Only_Matched_Entities()
+    {
+        const int entityCount = 50;
+        var entities = CreateEntities(entityCount);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        CloneCountingEntity.ResetCloneCount();
+
+        // Find 5 entities out of 50.
+        var targetIds = new HashSet<int> { 5, 10, 15, 20, 25 };
+        var found = policy.FindAllCached(x => targetIds.Contains(x.Id), _ => entities);
+
+        Assert.AreEqual(5, found.Length);
+        Assert.AreEqual(5, CloneCountingEntity.CloneCount, "FindAllCached should clone only the 5 matched entities, not all 50");
+    }
+
+    [Test]
+    public void FindAllCached_Returns_Empty_When_No_Match()
+    {
+        var entities = CreateEntities(10);
+        var policy = CreatePolicy();
+
+        // Populate cache.
+        policy.GetAll(null, _ => entities);
+
+        var found = policy.FindAllCached(x => x.Id > 999, _ => entities);
+
+        Assert.IsEmpty(found);
+    }
+
+    /// <summary>
+    /// A test entity that counts how many times DeepClone is called across all instances.
+    /// </summary>
+    private sealed class CloneCountingEntity : EntityBase
+    {
+        private static int _cloneCount;
+
+        public CloneCountingEntity(int id, string name)
+        {
+            DisableChangeTracking();
+            Id = id;
+            Name = name;
+            EnableChangeTracking();
+        }
+
+        public string Name { get; set; }
+
+        public static int CloneCount => _cloneCount;
+
+        public static void ResetCloneCount() => Interlocked.Exchange(ref _cloneCount, 0);
+
+        protected override void PerformDeepClone(object clone)
+        {
+            base.PerformDeepClone(clone);
+            Interlocked.Increment(ref _cloneCount);
+        }
+    }
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/FullDataSetCachePolicyTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/FullDataSetCachePolicyTests.cs
index 5158c6862654..d8569876f988 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/FullDataSetCachePolicyTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/FullDataSetCachePolicyTests.cs
@@ -407,59 +407,4 @@ public void GetAllCached_Is_ThreadSafe_During_Iteration_And_Cache_Clear()
             threadSafetyExceptions,
             $"Thread safety violation detected: {string.Join(Environment.NewLine, threadSafetyExceptions.Select(e => e.Message))}");
     }
-
-    /// <summary>
-    /// A simple non-thread-safe cache for testing purposes.
-    /// This allows race conditions to manifest that would be hidden by ObjectCacheAppCache's internal locking.
-    /// </summary>
-    private sealed class NonLockingCache : IAppPolicyCache
-    {
-        private readonly Dictionary<string, object?> _cache = [];
-
-        public object? Get(string key)
-            => _cache.TryGetValue(key, out var value) ? value : null;
-
-        public object? Get(string key, Func<object?> factory) => Get(key, factory, null, false);
-
-        public object? Get(string key, Func<object?> factory, TimeSpan? timeout, bool isSliding = false)
-        {
-            if (_cache.TryGetValue(key, out var value))
-            {
-                return value;
-            }
-
-            value = factory();
-            _cache[key] = value;
-            return value;
-        }
-
-        public IEnumerable<object> SearchByKey(string keyStartsWith)
-            => _cache.Where(kvp => kvp.Key.StartsWith(keyStartsWith)).Select(kvp => kvp.Value!);
-
-        public IEnumerable<object> SearchByRegex(string regex) => throw new NotImplementedException();
-
-        public void Clear() => _cache.Clear();
-
-        public void Clear(string key) => _cache.Remove(key);
-
-        public void ClearOfType(Type type) => throw new NotImplementedException();
-
-        public void ClearOfType<T>() => throw new NotImplementedException();
-
-        public void ClearOfType<T>(Func<string, T, bool> predicate) => throw new NotImplementedException();
-
-        public void ClearByKey(string keyStartsWith)
-        {
-            var keysToRemove = _cache.Keys.Where(k => k.StartsWith(keyStartsWith)).ToList();
-            foreach (var key in keysToRemove)
-            {
-                _cache.Remove(key);
-            }
-        }
-
-        public void ClearByRegex(string regex) => throw new NotImplementedException();
-
-        public void Insert(string key, Func<object?> factory, TimeSpan? timeout = null, bool isSliding = false)
-            => _cache[key] = factory();
-    }
 }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/NonLockingCache.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/NonLockingCache.cs
new file mode 100644
index 000000000000..bc9e1ea678be
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/NonLockingCache.cs
@@ -0,0 +1,61 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using Umbraco.Cms.Core.Cache;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Cache;
+
+/// <summary>
+/// A simple non-thread-safe cache for testing purposes.
+/// This allows race conditions to manifest that would be hidden by ObjectCacheAppCache's internal locking.
+/// </summary>
+internal sealed class NonLockingCache : IAppPolicyCache
+{
+    private readonly Dictionary<string, object?> _cache = [];
+
+    public object? Get(string key)
+        => _cache.TryGetValue(key, out var value) ? value : null;
+
+    public object? Get(string key, Func<object?> factory) => Get(key, factory, null, false);
+
+    public object? Get(string key, Func<object?> factory, TimeSpan? timeout, bool isSliding = false)
+    {
+        if (_cache.TryGetValue(key, out var value))
+        {
+            return value;
+        }
+
+        value = factory();
+        _cache[key] = value;
+        return value;
+    }
+
+    public IEnumerable<object> SearchByKey(string keyStartsWith)
+        => _cache.Where(kvp => kvp.Key.StartsWith(keyStartsWith, StringComparison.InvariantCultureIgnoreCase)).Select(kvp => kvp.Value!);
+
+    public IEnumerable<object> SearchByRegex(string regex) => throw new NotImplementedException();
+
+    public void Clear() => _cache.Clear();
+
+    public void Clear(string key) => _cache.Remove(key);
+
+    public void ClearOfType(Type type) => throw new NotImplementedException();
+
+    public void ClearOfType<T>() => throw new NotImplementedException();
+
+    public void ClearOfType<T>(Func<string, T, bool> predicate) => throw new NotImplementedException();
+
+    public void ClearByKey(string keyStartsWith)
+    {
+        var keysToRemove = _cache.Keys.Where(k => k.StartsWith(keyStartsWith, StringComparison.InvariantCultureIgnoreCase)).ToList();
+        foreach (var key in keysToRemove)
+        {
+            _cache.Remove(key);
+        }
+    }
+
+    public void ClearByRegex(string regex) => throw new NotImplementedException();
+
+    public void Insert(string key, Func<object?> factory, TimeSpan? timeout = null, bool isSliding = false)
+        => _cache[key] = factory();
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/RefresherTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/RefresherTests.cs
index 27ecf666563a..a02f3bf63fdc 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/RefresherTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Cache/RefresherTests.cs
@@ -110,6 +110,40 @@ public void ElementCacheRefresherCanDeserializeJsonPayload(TreeChangeTypes chang
         Assert.AreEqual(1234, payload[0].Id);
         Assert.AreEqual(key, payload[0].Key);
         Assert.AreEqual(changeTypes, payload[0].ChangeTypes);
+        Assert.IsNull(payload[0].PublishedCultures);
+        Assert.IsNull(payload[0].UnpublishedCultures);
+    }
+
+    [Test]
+    public void ElementCacheRefresherCanDeserializeJsonPayloadWithCultures()
+    {
+        var key = Guid.NewGuid();
+        ElementCacheRefresher.JsonPayload[] source =
+        {
+            new(1234, key, TreeChangeTypes.RefreshNode)
+            {
+                PublishedCultures = ["en-US", "da-DK"],
+                UnpublishedCultures = ["de-DE"]
+            }
+        };
+
+        var json = JsonSerializer.Serialize(source);
+        var payload = JsonSerializer.Deserialize<ElementCacheRefresher.JsonPayload[]>(json);
+
+        Assert.IsNotNull(payload[0].PublishedCultures);
+        Assert.Multiple(() =>
+        {
+            Assert.AreEqual(2, payload[0].PublishedCultures.Length);
+            Assert.AreEqual("en-US", payload[0].PublishedCultures.First());
+            Assert.AreEqual("da-DK", payload[0].PublishedCultures.Last());
+        });
+
+        Assert.IsNotNull(payload[0].UnpublishedCultures);
+        Assert.Multiple(() =>
+        {
+            Assert.AreEqual(1, payload[0].UnpublishedCultures.Length);
+            Assert.AreEqual("de-DE", payload[0].UnpublishedCultures.First());
+        });
     }
 
     [Test]
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Configuration/Models/Validation/HostingSettingsValidatorTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Configuration/Models/Validation/HostingSettingsValidatorTests.cs
new file mode 100644
index 000000000000..237842332b26
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Configuration/Models/Validation/HostingSettingsValidatorTests.cs
@@ -0,0 +1,49 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using NUnit.Framework;
+using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.Configuration.Models.Validation;
+using Umbraco.Cms.Core.Factories;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Configuration.Models.Validation;
+
+[TestFixture]
+public class HostingSettingsValidatorTests
+{
+    [Test]
+    public void Returns_Success_For_Default_Configuration()
+    {
+        var validator = new HostingSettingsValidator();
+        var options = new HostingSettings();
+        var result = validator.Validate("settings", options);
+        Assert.True(result.Succeeded);
+    }
+
+    [Test]
+    public void Returns_Success_For_Configuration_With_No_SiteName()
+    {
+        var validator = new HostingSettingsValidator();
+        var options = new HostingSettings { SiteName = null };
+        var result = validator.Validate("settings", options);
+        Assert.True(result.Succeeded);
+    }
+
+    [Test]
+    public void Returns_Success_For_Configuration_With_Short_SiteName()
+    {
+        var validator = new HostingSettingsValidator();
+        var options = new HostingSettings { SiteName = "site1" };
+        var result = validator.Validate("settings", options);
+        Assert.True(result.Succeeded);
+    }
+
+    [Test]
+    public void Returns_Fail_For_Configuration_With_SiteName_That_Exceeds_Max_Length()
+    {
+        var validator = new HostingSettingsValidator();
+        var options = new HostingSettings { SiteName = new string('x', MachineInfoFactory.MaxMachineIdentifierLength) };
+        var result = validator.Validate("settings", options);
+        Assert.False(result.Succeeded);
+    }
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Extensions/ContentTypeChangeExtensionsTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Extensions/ContentTypeChangeExtensionsTests.cs
index 596b97044760..b5196ed8bed4 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Extensions/ContentTypeChangeExtensionsTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Extensions/ContentTypeChangeExtensionsTests.cs
@@ -10,6 +10,7 @@ namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Extensions;
 [TestFixture]
 public class ContentTypeChangeExtensionsTests
 {
+    // "Main" base flags
     [TestCase(ContentTypeChangeTypes.RefreshMain, true)]
     [TestCase(ContentTypeChangeTypes.RefreshMain | ContentTypeChangeTypes.RefreshOther, true)]
     [TestCase(ContentTypeChangeTypes.RefreshMain | ContentTypeChangeTypes.Create, true)]
@@ -18,9 +19,19 @@ public class ContentTypeChangeExtensionsTests
     [TestCase(ContentTypeChangeTypes.Create, false)]
     [TestCase(ContentTypeChangeTypes.Remove, false)]
     [TestCase(ContentTypeChangeTypes.RefreshOther | ContentTypeChangeTypes.Remove, false)]
+    // Granular structural flags (all include RefreshMain)
+    [TestCase(ContentTypeChangeTypes.AliasChanged, true)]
+    [TestCase(ContentTypeChangeTypes.PropertyAliasChanged, true)]
+    [TestCase(ContentTypeChangeTypes.PropertyRemoved, true)]
+    [TestCase(ContentTypeChangeTypes.CompositionRemoved, true)]
+    [TestCase(ContentTypeChangeTypes.PropertyVariationChanged, true)]
+    // Granular non-structural flags (all include RefreshOther, but NOT RefreshMain)
+    [TestCase(ContentTypeChangeTypes.PropertyAdded, false)]
+    [TestCase(ContentTypeChangeTypes.CompositionAdded, false)]
     public void IsStructuralChange(ContentTypeChangeTypes change, bool expected) =>
         Assert.AreEqual(expected, change.IsStructuralChange());
 
+    // "Main" base flags
     [TestCase(ContentTypeChangeTypes.RefreshOther, true)]
     [TestCase(ContentTypeChangeTypes.RefreshOther | ContentTypeChangeTypes.Create, true)]
     [TestCase(ContentTypeChangeTypes.RefreshOther | ContentTypeChangeTypes.Remove, true)]
@@ -29,6 +40,97 @@ public void IsStructuralChange(ContentTypeChangeTypes change, bool expected) =>
     [TestCase(ContentTypeChangeTypes.None, false)]
     [TestCase(ContentTypeChangeTypes.Create, false)]
     [TestCase(ContentTypeChangeTypes.Remove, false)]
+    // Granular non-structural flags (include RefreshOther but not RefreshMain)
+    [TestCase(ContentTypeChangeTypes.PropertyAdded, true)]
+    [TestCase(ContentTypeChangeTypes.CompositionAdded, true)]
+    // Granular structural flags (include RefreshMain, so NOT non-structural)
+    [TestCase(ContentTypeChangeTypes.AliasChanged, false)]
+    [TestCase(ContentTypeChangeTypes.PropertyRemoved, false)]
+    [TestCase(ContentTypeChangeTypes.CompositionRemoved, false)]
+    [TestCase(ContentTypeChangeTypes.PropertyVariationChanged, false)]
+    // Mixed: structural + non-structural granular flags together (RefreshMain is set, so NOT non-structural)
+    [TestCase(ContentTypeChangeTypes.PropertyRemoved | ContentTypeChangeTypes.PropertyAdded, false)]
     public void IsNonStructuralChange(ContentTypeChangeTypes change, bool expected) =>
         Assert.AreEqual(expected, change.IsNonStructuralChange());
+
+    [Test]
+    public void Granular_Structural_Flags_Include_RefreshMain_Bit()
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(ContentTypeChangeTypes.AliasChanged.HasType(ContentTypeChangeTypes.RefreshMain));
+            Assert.IsTrue(ContentTypeChangeTypes.PropertyAliasChanged.HasType(ContentTypeChangeTypes.RefreshMain));
+            Assert.IsTrue(ContentTypeChangeTypes.PropertyRemoved.HasType(ContentTypeChangeTypes.RefreshMain));
+            Assert.IsTrue(ContentTypeChangeTypes.CompositionRemoved.HasType(ContentTypeChangeTypes.RefreshMain));
+            Assert.IsTrue(ContentTypeChangeTypes.PropertyVariationChanged.HasType(ContentTypeChangeTypes.RefreshMain));
+        });
+    }
+
+    [Test]
+    public void Granular_NonStructural_Flags_Include_RefreshOther_Bit()
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(ContentTypeChangeTypes.PropertyAdded.HasType(ContentTypeChangeTypes.RefreshOther));
+            Assert.IsTrue(ContentTypeChangeTypes.CompositionAdded.HasType(ContentTypeChangeTypes.RefreshOther));
+        });
+    }
+
+    [Test]
+    public void Granular_NonStructural_Flags_Do_Not_Include_RefreshMain_Bit()
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.IsFalse(ContentTypeChangeTypes.PropertyAdded.HasType(ContentTypeChangeTypes.RefreshMain));
+            Assert.IsFalse(ContentTypeChangeTypes.CompositionAdded.HasType(ContentTypeChangeTypes.RefreshMain));
+        });
+    }
+
+    [Test]
+    public void Combined_Granular_Flags_Are_Distinguishable()
+    {
+        var combined = ContentTypeChangeTypes.PropertyRemoved | ContentTypeChangeTypes.AliasChanged;
+
+        Assert.Multiple(() =>
+        {
+            Assert.IsTrue(combined.HasType(ContentTypeChangeTypes.PropertyRemoved));
+            Assert.IsTrue(combined.HasType(ContentTypeChangeTypes.AliasChanged));
+            Assert.IsTrue(combined.HasType(ContentTypeChangeTypes.RefreshMain));
+            // HasTypesAll checks that ALL bits of the target are set, which is the correct way
+            // to test for composite flags that share the RefreshMain bit
+            Assert.IsFalse(combined.HasTypesAll(ContentTypeChangeTypes.CompositionRemoved));
+            Assert.IsFalse(combined.HasTypesAll(ContentTypeChangeTypes.PropertyVariationChanged));
+            Assert.IsFalse(combined.HasType(ContentTypeChangeTypes.RefreshOther));
+        });
+    }
+
+    [TestCase(ContentTypeChangeTypes.AliasChanged, ContentTypeChangeTypes.RefreshMain)]
+    [TestCase(ContentTypeChangeTypes.PropertyAliasChanged, ContentTypeChangeTypes.RefreshMain)]
+    [TestCase(ContentTypeChangeTypes.PropertyRemoved, ContentTypeChangeTypes.RefreshMain)]
+    [TestCase(ContentTypeChangeTypes.CompositionRemoved, ContentTypeChangeTypes.RefreshMain)]
+    [TestCase(ContentTypeChangeTypes.PropertyVariationChanged, ContentTypeChangeTypes.RefreshMain)]
+    [TestCase(ContentTypeChangeTypes.PropertyAdded, ContentTypeChangeTypes.RefreshOther)]
+    [TestCase(ContentTypeChangeTypes.CompositionAdded, ContentTypeChangeTypes.RefreshOther)]
+    public void Sub_Flag_Yields_Positive_For_Main_Flag(ContentTypeChangeTypes subFlag, ContentTypeChangeTypes mainFlag)
+        => Assert.IsTrue(subFlag.HasFlag(mainFlag));
+
+    [TestCase(ContentTypeChangeTypes.AliasChanged, ContentTypeChangeTypes.RefreshMain)]
+    [TestCase(ContentTypeChangeTypes.PropertyAliasChanged, ContentTypeChangeTypes.RefreshMain)]
+    [TestCase(ContentTypeChangeTypes.PropertyRemoved, ContentTypeChangeTypes.RefreshMain)]
+    [TestCase(ContentTypeChangeTypes.CompositionRemoved, ContentTypeChangeTypes.RefreshMain)]
+    [TestCase(ContentTypeChangeTypes.PropertyVariationChanged, ContentTypeChangeTypes.RefreshMain)]
+    [TestCase(ContentTypeChangeTypes.PropertyAdded, ContentTypeChangeTypes.RefreshOther)]
+    [TestCase(ContentTypeChangeTypes.CompositionAdded, ContentTypeChangeTypes.RefreshOther)]
+    public void Main_Flag_Yields_Negative_For_Sub_Flag(ContentTypeChangeTypes subFlag, ContentTypeChangeTypes mainFlag)
+        => Assert.IsFalse(mainFlag.HasFlag(subFlag));
+
+    [TestCase(ContentTypeChangeTypes.AliasChanged, ContentTypeChangeTypes.PropertyAliasChanged)]
+    [TestCase(ContentTypeChangeTypes.PropertyAliasChanged, ContentTypeChangeTypes.PropertyRemoved)]
+    [TestCase(ContentTypeChangeTypes.PropertyRemoved, ContentTypeChangeTypes.CompositionRemoved)]
+    [TestCase(ContentTypeChangeTypes.CompositionRemoved, ContentTypeChangeTypes.PropertyVariationChanged)]
+    [TestCase(ContentTypeChangeTypes.PropertyVariationChanged, ContentTypeChangeTypes.AliasChanged)]
+    [TestCase(ContentTypeChangeTypes.PropertyAdded, ContentTypeChangeTypes.CompositionAdded)]
+    [TestCase(ContentTypeChangeTypes.CompositionAdded, ContentTypeChangeTypes.PropertyAdded)]
+    public void Sub_Flag_Yields_Negative_For_Other_Sub_Flag(ContentTypeChangeTypes subFlag1, ContentTypeChangeTypes subFlag2)
+        => Assert.IsFalse(subFlag1.HasFlag(subFlag2));
 }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Factories/MachineInfoFactoryTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Factories/MachineInfoFactoryTests.cs
new file mode 100644
index 000000000000..cc34d46d853d
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Factories/MachineInfoFactoryTests.cs
@@ -0,0 +1,92 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using Microsoft.Extensions.Options;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.Factories;
+using Umbraco.Cms.Core.Hosting;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Factories;
+
+[TestFixture]
+public class MachineInfoFactoryTests
+{
+    [Test]
+    public void BuildMachineIdentifier_WithNoSiteName_ReturnsMachineNameOnly()
+    {
+        var result = MachineInfoFactory.BuildMachineIdentifier("SERVER01", null);
+        Assert.AreEqual("SERVER01", result);
+    }
+
+    [Test]
+    public void BuildMachineIdentifier_WithEmptySiteName_ReturnsMachineNameOnly()
+    {
+        var result = MachineInfoFactory.BuildMachineIdentifier("SERVER01", string.Empty);
+        Assert.AreEqual("SERVER01", result);
+    }
+
+    [Test]
+    public void BuildMachineIdentifier_WithWhitespaceSiteName_ReturnsMachineNameOnly()
+    {
+        var result = MachineInfoFactory.BuildMachineIdentifier("SERVER01", "   ");
+        Assert.AreEqual("SERVER01", result);
+    }
+
+    [Test]
+    public void BuildMachineIdentifier_WithSiteName_ReturnsMachineNameSlashSiteName()
+    {
+        var result = MachineInfoFactory.BuildMachineIdentifier("SERVER01", "site1");
+        Assert.AreEqual("SERVER01/site1", result);
+    }
+
+    [Test]
+    public void GetMachineIdentifier_WithNoSiteName_ReturnsSameResultAsBuildMachineIdentifier()
+    {
+        var factory = CreateFactory(siteName: null);
+        var result = factory.GetMachineIdentifier();
+        Assert.AreEqual(MachineInfoFactory.BuildMachineIdentifier(Environment.MachineName, null), result);
+    }
+
+    [Test]
+    public void GetMachineIdentifier_WithEmptySiteName_ReturnsSameResultAsBuildMachineIdentifier()
+    {
+        var factory = CreateFactory(siteName: string.Empty);
+        var result = factory.GetMachineIdentifier();
+        Assert.AreEqual(MachineInfoFactory.BuildMachineIdentifier(Environment.MachineName, string.Empty), result);
+    }
+
+    [Test]
+    public void GetMachineIdentifier_WithWhitespaceSiteName_ReturnsSameResultAsBuildMachineIdentifier()
+    {
+        var factory = CreateFactory(siteName: "   ");
+        var result = factory.GetMachineIdentifier();
+        Assert.AreEqual(MachineInfoFactory.BuildMachineIdentifier(Environment.MachineName, "   "), result);
+    }
+
+    [Test]
+    public void GetMachineIdentifier_WithSiteName_ReturnsSameResultAsBuildMachineIdentifier()
+    {
+        var factory = CreateFactory(siteName: "site1");
+        var result = factory.GetMachineIdentifier();
+        Assert.AreEqual(MachineInfoFactory.BuildMachineIdentifier(Environment.MachineName, "site1"), result);
+    }
+
+    [Test]
+    public void GetMachineIdentifier_WithSiteNameThatExceedsMaxLength_ThrowsInvalidOperationException()
+    {
+        var siteName = new string('x', MachineInfoFactory.MaxMachineIdentifierLength);
+
+        var factory = CreateFactory(siteName);
+
+        Assert.Throws<InvalidOperationException>(() => factory.GetMachineIdentifier());
+    }
+
+    private static MachineInfoFactory CreateFactory(string? siteName)
+    {
+        var hostingEnvironment = Mock.Of<IHostingEnvironment>();
+        var hostingSettings = Options.Create(new HostingSettings { SiteName = siteName });
+        return new MachineInfoFactory(hostingEnvironment, hostingSettings);
+    }
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/IO/PhysicalFileSystemTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/IO/PhysicalFileSystemTests.cs
index 7893c8a6f629..2476f69c0429 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/IO/PhysicalFileSystemTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/IO/PhysicalFileSystemTests.cs
@@ -2,6 +2,7 @@
 // See LICENSE for more details.
 
 using System.Text;
+using Microsoft.Extensions.FileProviders;
 using Microsoft.Extensions.Logging;
 using Moq;
 using NUnit.Framework;
@@ -103,4 +104,32 @@ public void GetFullPathTest()
         // that path is invalid as it would be outside the root directory
         Assert.Throws<UnauthorizedAccessException>(() => _fileSystem.GetFullPath("../../foo.tmp"));
     }
+
+    [Test]
+    public void CreateFileProviderCreatesDirectoryIfMissing()
+    {
+        var nonExistentPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "FileSysTests", "NonExistent");
+        if (Directory.Exists(nonExistentPath))
+        {
+            Directory.Delete(nonExistentPath, true);
+        }
+
+        var fs = new PhysicalFileSystem(
+            TestHelper.IOHelper,
+            TestHelper.GetHostingEnvironment(),
+            Mock.Of<ILogger<PhysicalFileSystem>>(),
+            nonExistentPath,
+            "/Media/");
+
+        IFileProvider fileProvider = ((IFileProviderFactory)fs).Create();
+        try
+        {
+            Assert.IsNotNull(fileProvider);
+            Assert.IsTrue(Directory.Exists(nonExistentPath));
+        }
+        finally
+        {
+            (fileProvider as IDisposable)?.Dispose();
+        }
+    }
 }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/PropertyEditors/RichTextAllowedMediaTypeValidatorTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/PropertyEditors/RichTextAllowedMediaTypeValidatorTests.cs
new file mode 100644
index 000000000000..6ed3eaa01812
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/PropertyEditors/RichTextAllowedMediaTypeValidatorTests.cs
@@ -0,0 +1,174 @@
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core.Cache;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Validation;
+using Umbraco.Cms.Core.PropertyEditors;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Templates;
+using Umbraco.Cms.Infrastructure.Serialization;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.PropertyEditors;
+
+[TestFixture]
+internal class RichTextAllowedMediaTypeValidatorTests
+{
+    private static readonly Guid AllowedTypeKey = Guid.NewGuid();
+
+    [TestCase(null)]
+    [TestCase("")]
+    public void No_Filter_Configured_Allows_All(string? allowedMediaTypes)
+    {
+        var (validator, _, _) = CreateValidator();
+
+        var result = Validate(validator, BuildMarkup(Guid.NewGuid()), allowedMediaTypes);
+
+        Assert.IsEmpty(result);
+    }
+
+    [Test]
+    public void No_Media_References_Passes()
+    {
+        var (validator, _, _) = CreateValidator();
+
+        var result = Validate(validator, "<p>No images here</p>");
+
+        Assert.IsEmpty(result);
+    }
+
+    [Test]
+    public void Allowed_Media_Type_Passes()
+    {
+        var (validator, mediaServiceMock, mediaTypeServiceMock) = CreateValidator();
+        SetupMedia(mediaServiceMock, mediaTypeServiceMock, "Image", AllowedTypeKey);
+
+        var result = Validate(validator, BuildMarkup(Guid.NewGuid()));
+
+        Assert.IsEmpty(result);
+    }
+
+    [Test]
+    public void Disallowed_Media_Type_Fails()
+    {
+        var (validator, mediaServiceMock, mediaTypeServiceMock) = CreateValidator();
+        SetupMedia(mediaServiceMock, mediaTypeServiceMock, "File", Guid.NewGuid());
+
+        var result = Validate(validator, BuildMarkup(Guid.NewGuid()));
+
+        Assert.That(result.Count(), Is.EqualTo(1));
+    }
+
+    [Test]
+    public void One_Disallowed_Among_Multiple_Fails()
+    {
+        var (validator, mediaServiceMock, mediaTypeServiceMock) = CreateValidator();
+
+        var allowed = CreateMediaMock("Image");
+        var disallowed = CreateMediaMock("File");
+        mediaServiceMock.Setup(x => x.GetByIds(It.IsAny<IEnumerable<Guid>>()))
+            .Returns([allowed.Object, disallowed.Object]);
+        SetupMediaType(mediaTypeServiceMock, "Image", AllowedTypeKey);
+        SetupMediaType(mediaTypeServiceMock, "File", Guid.NewGuid());
+
+        var result = Validate(validator, BuildMarkup(Guid.NewGuid()) + BuildMarkup(Guid.NewGuid()));
+
+        Assert.That(result.Count(), Is.EqualTo(1));
+    }
+
+    [Test]
+    public void Media_Not_Found_Passes()
+    {
+        var (validator, mediaServiceMock, _) = CreateValidator();
+        mediaServiceMock.Setup(x => x.GetByIds(It.IsAny<IEnumerable<Guid>>())).Returns([]);
+
+        var result = Validate(validator, BuildMarkup(Guid.NewGuid()));
+
+        Assert.IsEmpty(result);
+    }
+
+    [Test]
+    public void Media_Type_Not_Found_Fails()
+    {
+        var (validator, mediaServiceMock, mediaTypeServiceMock) = CreateValidator();
+        var media = CreateMediaMock("Unknown");
+        mediaServiceMock.Setup(x => x.GetByIds(It.IsAny<IEnumerable<Guid>>())).Returns([media.Object]);
+        mediaTypeServiceMock.Setup(x => x.Get(It.IsAny<string>())).Returns((IMediaType?)null);
+
+        var result = Validate(validator, BuildMarkup(Guid.NewGuid()));
+
+        Assert.That(result.Count(), Is.EqualTo(1));
+    }
+
+    [Test]
+    public void Multiple_Allowed_Types_In_Config()
+    {
+        var secondTypeKey = Guid.NewGuid();
+        var (validator, mediaServiceMock, mediaTypeServiceMock) = CreateValidator();
+        SetupMedia(mediaServiceMock, mediaTypeServiceMock, "Video", secondTypeKey);
+
+        var result = Validate(validator, BuildMarkup(Guid.NewGuid()), $"{AllowedTypeKey},{secondTypeKey}");
+
+        Assert.IsEmpty(result);
+    }
+
+    [Test]
+    public void Allowed_Type_Key_Comparison_Is_Case_Insensitive()
+    {
+        var (validator, mediaServiceMock, mediaTypeServiceMock) = CreateValidator();
+        SetupMedia(mediaServiceMock, mediaTypeServiceMock, "Image", AllowedTypeKey);
+
+        var result = Validate(validator, BuildMarkup(Guid.NewGuid()), AllowedTypeKey.ToString().ToUpperInvariant());
+
+        Assert.IsEmpty(result);
+    }
+
+    private static IEnumerable<System.ComponentModel.DataAnnotations.ValidationResult> Validate(
+        RichTextAllowedMediaTypeValidator validator,
+        string markup,
+        string? allowedMediaTypes = "USE_DEFAULT") =>
+        validator.Validate(
+            $$"""{"markup":"{{markup.Replace("\"", "\\\"")}}","blocks":null}""",
+            null,
+            new RichTextConfiguration { AllowedMediaTypes = allowedMediaTypes == "USE_DEFAULT" ? AllowedTypeKey.ToString() : allowedMediaTypes },
+            PropertyValidationContext.Empty());
+
+    private static string BuildMarkup(Guid mediaKey) =>
+        $"""<img src="/media/image.jpg" data-udi="umb://media/{mediaKey:N}" />""";
+
+    private static Mock<IMedia> CreateMediaMock(string typeAlias)
+    {
+        var mock = new Mock<IMedia>();
+        mock.SetupGet(x => x.ContentType.Alias).Returns(typeAlias);
+        return mock;
+    }
+
+    private static void SetupMediaType(Mock<IMediaTypeService> mock, string alias, Guid key)
+    {
+        var mediaType = new Mock<IMediaType>();
+        mediaType.Setup(x => x.Key).Returns(key);
+        mock.Setup(x => x.Get(alias)).Returns(mediaType.Object);
+    }
+
+    private static void SetupMedia(Mock<IMediaService> mediaServiceMock, Mock<IMediaTypeService> mediaTypeServiceMock, string typeAlias, Guid typeKey)
+    {
+        var media = CreateMediaMock(typeAlias);
+        mediaServiceMock.Setup(x => x.GetByIds(It.IsAny<IEnumerable<Guid>>())).Returns([media.Object]);
+        SetupMediaType(mediaTypeServiceMock, typeAlias, typeKey);
+    }
+
+    private static (RichTextAllowedMediaTypeValidator Validator, Mock<IMediaService> MediaServiceMock, Mock<IMediaTypeService> MediaTypeServiceMock) CreateValidator()
+    {
+        var mediaServiceMock = new Mock<IMediaService>();
+        var mediaTypeServiceMock = new Mock<IMediaTypeService>();
+
+        var validator = new RichTextAllowedMediaTypeValidator(
+            new HtmlImageSourceParser(_ => string.Empty),
+            mediaServiceMock.Object,
+            Mock.Of<ILocalizedTextService>(),
+            new SystemTextJsonSerializer(new DefaultJsonSerializerEncoderFactory()),
+            Mock.Of<Microsoft.Extensions.Logging.ILogger>(),
+            new AllowedMediaTypeHelper(mediaTypeServiceMock.Object, AppCaches.Disabled));
+
+        return (validator, mediaServiceMock, mediaTypeServiceMock);
+    }
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/ConvertersTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/ConvertersTests.cs
index f5a458df8dcd..3f7d02d1e59a 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/ConvertersTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/ConvertersTests.cs
@@ -110,9 +110,10 @@ public void SimpleConverter2Test()
 
         var serializer = new SystemTextConfigurationEditorJsonSerializer(new DefaultJsonSerializerEncoderFactory());
         var dataTypeServiceMock = new Mock<IDataTypeService>();
+        var dataTypeKey = Guid.NewGuid();
         var dataType = new DataType(
             new VoidEditor(Mock.Of<IDataValueEditorFactory>()), serializer)
-        { Id = 1 };
+        { Id = 1, Key = dataTypeKey };
         dataTypeServiceMock.Setup(x => x.GetAll()).Returns(dataType.Yield);
 
         var contentTypeFactory =
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/PropertyCacheLevelTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/PropertyCacheLevelTests.cs
index d04ca0febf24..1532e8dd26ec 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/PropertyCacheLevelTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Published/PropertyCacheLevelTests.cs
@@ -1,10 +1,8 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
-using System.Collections.Generic;
 using Moq;
 using NUnit.Framework;
-using Umbraco.Cms.Core.Cache;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.PublishedContent;
 using Umbraco.Cms.Core.PropertyEditors;
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/ContentFinderByUrlNewTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/ContentFinderByUrlNewTests.cs
index 976a03f41f6d..76f37b08d2b8 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/ContentFinderByUrlNewTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/ContentFinderByUrlNewTests.cs
@@ -128,13 +128,13 @@ private static Mock<IPublishedContentCache> CreateMockPublishedContentCache(Mock
         return mockPublishedContentCache;
     }
 
-    private static ContentFinderByUrlNew CreateContentFinder(
+    private static ContentFinderByUrl CreateContentFinder(
         Mock<IUmbracoContextAccessor> mockUmbracoContextAccessor,
         Mock<IDocumentUrlService> mockDocumentUrlService,
         Mock<IPublishedContentCache> mockPublishedContentCache,
         WebRoutingSettings? webRoutingSettings = null)
         => new(
-            new NullLogger<ContentFinderByUrlNew>(),
+            new NullLogger<ContentFinderByUrl>(),
             mockUmbracoContextAccessor.Object,
             mockDocumentUrlService.Object,
             mockPublishedContentCache.Object,
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/NewDefaultUrlProviderTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/NewDefaultUrlProviderTests.cs
new file mode 100644
index 000000000000..75efe4b8732a
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Routing/NewDefaultUrlProviderTests.cs
@@ -0,0 +1,495 @@
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.Hosting;
+using Umbraco.Cms.Core.Models.PublishedContent;
+using Umbraco.Cms.Core.PublishedCache;
+using Umbraco.Cms.Core.Routing;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.Navigation;
+using Umbraco.Cms.Core.Web;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Routing;
+
+[TestFixture]
+public class NewDefaultUrlProviderTests
+{
+    private static readonly Uri _currentUri = new("http://localhost", UriKind.Absolute);
+
+    private delegate void TryGetUmbracoContextDelegate(out IUmbracoContext? umbracoContext);
+
+    private sealed class TestContext
+    {
+        public Mock<IUmbracoContextAccessor> UmbracoContextAccessor { get; } = new();
+
+        public Mock<IUmbracoContext> UmbracoContext { get; } = new();
+
+        public Mock<IPublishedContentCache> PublishedContentCache { get; } = new();
+
+        public Mock<IDomainCache> DomainCache { get; } = new();
+
+        public Mock<ISiteDomainMapper> SiteDomainMapper { get; } = new();
+
+        public Mock<IIdKeyMap> IdKeyMap { get; } = new();
+
+        public Mock<IDocumentUrlService> DocumentUrlService { get; } = new();
+
+        public Mock<IDocumentNavigationQueryService> NavigationQueryService { get; } = new();
+
+        public Mock<IPublishedContentStatusFilteringService> StatusFilteringService { get; } = new();
+
+        public Mock<ILanguageService> LanguageService { get; } = new();
+
+        public RequestHandlerSettings RequestConfig { get; set; } = new() { AddTrailingSlash = true };
+
+        public string DefaultCulture { get; set; } = "en-US";
+
+        public TestContext()
+        {
+            UmbracoContextAccessor
+                .Setup(x => x.TryGetUmbracoContext(out It.Ref<IUmbracoContext?>.IsAny))
+                .Callback(new TryGetUmbracoContextDelegate((out IUmbracoContext? ctx) => ctx = UmbracoContext.Object))
+                .Returns(true);
+            UmbracoContext.Setup(x => x.Content).Returns(PublishedContentCache.Object);
+            UmbracoContext.Setup(x => x.Domains).Returns(DomainCache.Object);
+
+            DomainCache.Setup(x => x.GetAssigned(It.IsAny<int>(), It.IsAny<bool>()))
+                .Returns(Enumerable.Empty<Domain>());
+
+            LanguageService.Setup(x => x.GetDefaultIsoCodeAsync())
+                .ReturnsAsync(() => DefaultCulture);
+        }
+
+        public DefaultUrlProvider CreateProvider()
+        {
+            var hostingEnv = new Mock<IHostingEnvironment>();
+            hostingEnv.Setup(x => x.ApplicationVirtualPath).Returns("/");
+            var uriUtility = new UriUtility(hostingEnv.Object);
+
+            var optionsMonitor = new Mock<IOptionsMonitor<RequestHandlerSettings>>();
+            optionsMonitor.Setup(x => x.CurrentValue).Returns(RequestConfig);
+
+            return new DefaultUrlProvider(
+                optionsMonitor.Object,
+                Mock.Of<ILogger<DefaultUrlProvider>>(),
+                SiteDomainMapper.Object,
+                UmbracoContextAccessor.Object,
+                uriUtility,
+                PublishedContentCache.Object,
+                DomainCache.Object,
+                IdKeyMap.Object,
+                DocumentUrlService.Object,
+                NavigationQueryService.Object,
+                StatusFilteringService.Object,
+                LanguageService.Object);
+        }
+
+        public void SetupDomainForNode(int nodeId, DomainAndUri domainAndUri)
+        {
+            var domain = new Domain(1, domainAndUri.Name, nodeId, domainAndUri.Culture, false, 0);
+            DomainCache.Setup(x => x.GetAssigned(nodeId, It.IsAny<bool>()))
+                .Returns(new[] { domain });
+
+            SiteDomainMapper.Setup(x => x.MapDomain(
+                    It.IsAny<IReadOnlyCollection<DomainAndUri>>(),
+                    It.IsAny<Uri>(),
+                    It.IsAny<string?>(),
+                    It.IsAny<string?>()))
+                .Returns(domainAndUri);
+        }
+    }
+
+    /// <summary>
+    /// Verifies that a null route returns null (unpublished content).
+    /// </summary>
+    [Test]
+    public void Can_Return_Null_For_Null_Route()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute(null, 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Null);
+    }
+
+    /// <summary>
+    /// Verifies that an empty string route returns null (unpublished content).
+    /// </summary>
+    [Test]
+    public void Can_Return_Null_For_Empty_Route()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute(string.Empty, 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Null);
+    }
+
+    /// <summary>
+    /// Verifies that a whitespace-only route returns null (unpublished content).
+    /// </summary>
+    [Test]
+    public void Can_Return_Null_For_Whitespace_Route()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("   ", 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Null);
+    }
+
+    /// <summary>
+    /// Verifies that the "#" route marker returns null (unpublished content).
+    /// </summary>
+    [Test]
+    public void Can_Return_Null_For_Hash_Route()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("#", 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Null);
+    }
+
+    /// <summary>
+    /// Verifies that a root path "/" produces a relative URL of "/".
+    /// </summary>
+    [Test]
+    public void Can_Get_Relative_Url_For_Root_Path()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/", 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("/"));
+    }
+
+    /// <summary>
+    /// Verifies that a simple path-only route produces a relative URL with trailing slash.
+    /// </summary>
+    [Test]
+    public void Can_Get_Relative_Url_For_Simple_Path()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/my-page", 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("/my-page/"));
+    }
+
+    /// <summary>
+    /// Verifies that a nested path route produces the correct relative URL.
+    /// </summary>
+    [Test]
+    public void Can_Get_Relative_Url_For_Nested_Path()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/parent/child/grandchild", 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("/parent/child/grandchild/"));
+    }
+
+    /// <summary>
+    /// Verifies that UrlMode.Absolute produces an absolute URL including the authority.
+    /// </summary>
+    [Test]
+    public void Can_Get_Absolute_Url_For_Path_When_Mode_Is_Absolute()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/my-page", 123, _currentUri, UrlMode.Absolute, null);
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("http://localhost/my-page/"));
+    }
+
+    /// <summary>
+    /// Verifies that a route with a domain root ID prefix resolves to the domain-based URL.
+    /// </summary>
+    [Test]
+    public void Can_Get_Url_For_Route_With_Domain_Root_Id()
+    {
+        var ctx = new TestContext();
+        var domainAndUri = new DomainAndUri(
+            new Domain(1, "http://example.com", 100, "en-US", false, 0),
+            _currentUri);
+        ctx.SetupDomainForNode(100, domainAndUri);
+
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("100/my-page", 123, _currentUri, UrlMode.Absolute, "en-US");
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("http://example.com/my-page/"));
+    }
+
+    /// <summary>
+    /// Verifies that a route with domain root ID and root path "/" produces the domain root URL.
+    /// </summary>
+    [Test]
+    public void Can_Get_Url_For_Route_With_Domain_Root_Id_And_Root_Path()
+    {
+        var ctx = new TestContext();
+        var domainAndUri = new DomainAndUri(
+            new Domain(1, "http://example.com", 100, "en-US", false, 0),
+            _currentUri);
+        ctx.SetupDomainForNode(100, domainAndUri);
+
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("100/", 123, _currentUri, UrlMode.Absolute, "en-US");
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("http://example.com/"));
+    }
+
+    /// <summary>
+    /// Regression test for issue #22308: a route of just "1234" (domain root ID without slash separator)
+    /// occurs when the original path was "/" and got trimmed. Previously threw ArgumentOutOfRangeException
+    /// and crashed the Redirect URL Management dashboard.
+    /// </summary>
+    [Test]
+    public void Can_Handle_Route_Without_Slash_Separator()
+    {
+        var ctx = new TestContext();
+        var domainAndUri = new DomainAndUri(
+            new Domain(1, "http://example.com", 1234, "en-US", false, 0),
+            _currentUri);
+        ctx.SetupDomainForNode(1234, domainAndUri);
+
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("1234", 123, _currentUri, UrlMode.Absolute, "en-US");
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("http://example.com/"));
+    }
+
+    /// <summary>
+    /// Verifies that a numeric route without slash does not throw when no domain is configured,
+    /// falling back to a relative root URL.
+    /// </summary>
+    [Test]
+    public void Can_Handle_Route_Without_Slash_When_No_Domain_Configured()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("9999", 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("/"));
+    }
+
+    /// <summary>
+    /// Verifies that a non-numeric route without slash (malformed data) does not throw.
+    /// The int.TryParse fails gracefully, and domainUri stays null.
+    /// </summary>
+    [Test]
+    public void Can_Handle_Non_Numeric_Route_Without_Slash()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("notanumber", 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("/"));
+    }
+
+    /// <summary>
+    /// Verifies that a non-default culture without a matching domain returns null,
+    /// because only the default culture is served without a domain.
+    /// </summary>
+    [Test]
+    public void Can_Return_Null_When_Culture_Does_Not_Match_Default_And_No_Domain()
+    {
+        var ctx = new TestContext { DefaultCulture = "en-US" };
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/my-page", 123, _currentUri, UrlMode.Auto, "fr-FR");
+
+        Assert.That(result, Is.Null);
+    }
+
+    /// <summary>
+    /// Verifies that the default culture produces a URL even without a domain.
+    /// </summary>
+    [Test]
+    public void Can_Get_Url_When_Culture_Matches_Default()
+    {
+        var ctx = new TestContext { DefaultCulture = "en-US" };
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/my-page", 123, _currentUri, UrlMode.Auto, "en-US");
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("/my-page/"));
+    }
+
+    /// <summary>
+    /// Verifies that culture matching against the default is case-insensitive.
+    /// </summary>
+    [Test]
+    public void Can_Get_Url_When_Culture_Matches_Default_Case_Insensitive()
+    {
+        var ctx = new TestContext { DefaultCulture = "en-US" };
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/my-page", 123, _currentUri, UrlMode.Auto, "EN-us");
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("/my-page/"));
+    }
+
+    /// <summary>
+    /// Verifies that a null culture (invariant content) always produces a URL.
+    /// </summary>
+    [Test]
+    public void Can_Get_Url_When_Culture_Is_Null()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/my-page", 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Not.Null);
+    }
+
+    /// <summary>
+    /// Verifies that an empty culture string (invariant content) always produces a URL.
+    /// </summary>
+    [Test]
+    public void Can_Get_Url_When_Culture_Is_Empty()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/my-page", 123, _currentUri, UrlMode.Auto, string.Empty);
+
+        Assert.That(result, Is.Not.Null);
+    }
+
+    /// <summary>
+    /// Verifies that a non-default culture with a matching domain produces the correct domain-based URL.
+    /// </summary>
+    [Test]
+    public void Can_Get_Url_When_Non_Default_Culture_Has_Domain()
+    {
+        var ctx = new TestContext { DefaultCulture = "en-US" };
+        var domainAndUri = new DomainAndUri(
+            new Domain(1, "http://fr.example.com", 100, "fr-FR", false, 0),
+            _currentUri);
+        ctx.SetupDomainForNode(100, domainAndUri);
+
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("100/ma-page", 123, _currentUri, UrlMode.Absolute, "fr-FR");
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("http://fr.example.com/ma-page/"));
+        Assert.That(result.Culture, Is.EqualTo("fr-FR"));
+    }
+
+    /// <summary>
+    /// Verifies that Auto mode produces a relative URL when the domain authority matches the current request.
+    /// </summary>
+    [Test]
+    public void Can_Get_Relative_Url_When_Domain_Matches_Current_Request()
+    {
+        var ctx = new TestContext();
+        var domainAndUri = new DomainAndUri(
+            new Domain(1, "http://localhost", 100, "en-US", false, 0),
+            _currentUri);
+        ctx.SetupDomainForNode(100, domainAndUri);
+
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("100/my-page", 123, _currentUri, UrlMode.Auto, "en-US");
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("/my-page/"));
+    }
+
+    /// <summary>
+    /// Verifies that Auto mode produces an absolute URL when the domain differs from the current request.
+    /// </summary>
+    [Test]
+    public void Can_Get_Absolute_Url_When_Domain_Differs_From_Current_Request()
+    {
+        var ctx = new TestContext();
+        var domainAndUri = new DomainAndUri(
+            new Domain(1, "http://example.com", 100, "en-US", false, 0),
+            _currentUri);
+        ctx.SetupDomainForNode(100, domainAndUri);
+
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("100/my-page", 123, _currentUri, UrlMode.Auto, "en-US");
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("http://example.com/my-page/"));
+    }
+
+    /// <summary>
+    /// Verifies that the trailing slash is omitted when AddTrailingSlash is disabled.
+    /// </summary>
+    [Test]
+    public void Cannot_Get_Trailing_Slash_When_Setting_Disabled()
+    {
+        var ctx = new TestContext
+        {
+            RequestConfig = new RequestHandlerSettings { AddTrailingSlash = false },
+        };
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/my-page", 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Url!.ToString(), Is.EqualTo("/my-page"));
+    }
+
+    /// <summary>
+    /// Verifies that the UrlInfo Provider property is set to the content URL provider alias.
+    /// </summary>
+    [Test]
+    public void Can_Return_Correct_Provider_On_UrlInfo()
+    {
+        var ctx = new TestContext();
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/test", 123, _currentUri, UrlMode.Auto, null);
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Provider, Is.EqualTo("umbDocumentUrlProvider"));
+    }
+
+    /// <summary>
+    /// Verifies that the culture is correctly propagated to the UrlInfo result.
+    /// </summary>
+    [Test]
+    public void Can_Return_Culture_On_UrlInfo()
+    {
+        var ctx = new TestContext { DefaultCulture = "en-US" };
+        var provider = ctx.CreateProvider();
+
+        var result = provider.GetUrlFromRoute("/test", 123, _currentUri, UrlMode.Auto, "en-US");
+
+        Assert.That(result, Is.Not.Null);
+        Assert.That(result!.Culture, Is.EqualTo("en-US"));
+    }
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Security/ContentPermissionsTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Security/ContentPermissionsTests.cs
deleted file mode 100644
index ff945e78bccc..000000000000
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Security/ContentPermissionsTests.cs
+++ /dev/null
@@ -1,353 +0,0 @@
-// Copyright (c) Umbraco.
-// See LICENSE for more details.
-
-using Moq;
-using NUnit.Framework;
-using Umbraco.Cms.Core.Cache;
-using Umbraco.Cms.Core.Models;
-using Umbraco.Cms.Core.Models.Entities;
-using Umbraco.Cms.Core.Models.Membership;
-using Umbraco.Cms.Core.Security;
-using Umbraco.Cms.Core.Services;
-using Umbraco.Cms.Tests.Common.Builders;
-using Umbraco.Cms.Tests.Common.Builders.Extensions;
-
-namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Security;
-
-[TestFixture]
-public class ContentPermissionsTests
-{
-    [Test]
-    public void Access_Allowed_By_Path()
-    {
-        // Arrange
-        var user = CreateUser(9);
-        var contentMock = new Mock<IContent>();
-        contentMock.Setup(c => c.Path).Returns("-1,1234,5678");
-        var content = contentMock.Object;
-        var contentServiceMock = new Mock<IContentService>();
-        contentServiceMock.Setup(x => x.GetById(1234)).Returns(content);
-        var contentService = contentServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        var entityService = entityServiceMock.Object;
-        var userServiceMock = new Mock<IUserService>();
-        var userService = userServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(1234, user, out IContent _);
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Granted, result);
-    }
-
-    [Test]
-    public void No_Content_Found()
-    {
-        // Arrange
-        var user = CreateUser(9);
-        var contentMock = new Mock<IContent>();
-        contentMock.Setup(c => c.Path).Returns("-1,1234,5678");
-        var content = contentMock.Object;
-        var contentServiceMock = new Mock<IContentService>();
-        contentServiceMock.Setup(x => x.GetById(0)).Returns(content);
-        var contentService = contentServiceMock.Object;
-        var userServiceMock = new Mock<IUserService>();
-        var permissions = new EntityPermissionCollection();
-        var permissionSet = new EntityPermissionSet(1234, permissions);
-        userServiceMock.Setup(x => x.GetPermissionsForPath(user, "-1,1234,5678")).Returns(permissionSet);
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        var entityService = entityServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(1234, user, out IContent _, new[] { "F" }.ToHashSet());
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.NotFound, result);
-    }
-
-    [Test]
-    public void No_Access_By_Path()
-    {
-        // Arrange
-        var user = CreateUser(9, 9876);
-        var contentMock = new Mock<IContent>();
-        contentMock.Setup(c => c.Path).Returns("-1,1234,5678");
-        var content = contentMock.Object;
-        var contentServiceMock = new Mock<IContentService>();
-        contentServiceMock.Setup(x => x.GetById(1234)).Returns(content);
-        var contentService = contentServiceMock.Object;
-        var userServiceMock = new Mock<IUserService>();
-        var permissions = new EntityPermissionCollection();
-        var permissionSet = new EntityPermissionSet(1234, permissions);
-        userServiceMock.Setup(x => x.GetPermissionsForPath(user, "-1,1234")).Returns(permissionSet);
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        entityServiceMock.Setup(x => x.GetAllPaths(It.IsAny<UmbracoObjectTypes>(), It.IsAny<int[]>()))
-            .Returns(new[] { Mock.Of<TreeEntityPath>(entity => entity.Id == 9876 && entity.Path == "-1,9876") });
-        var entityService = entityServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(1234, user, out IContent _, new[] { "F" }.ToHashSet());
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Denied, result);
-    }
-
-    [Test]
-    public void No_Access_By_Permission()
-    {
-        // Arrange
-        var user = CreateUser(9);
-        var contentMock = new Mock<IContent>();
-        contentMock.Setup(c => c.Path).Returns("-1,1234,5678");
-        var content = contentMock.Object;
-        var contentServiceMock = new Mock<IContentService>();
-        contentServiceMock.Setup(x => x.GetById(1234)).Returns(content);
-        var contentService = contentServiceMock.Object;
-        var userServiceMock = new Mock<IUserService>();
-        var permissions = new EntityPermissionCollection { new(9876, 1234, new[] { "A", "B", "C" }.ToHashSet()) };
-        var permissionSet = new EntityPermissionSet(1234, permissions);
-        userServiceMock.Setup(x => x.GetPermissionsForPath(user, "-1,1234,5678")).Returns(permissionSet);
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        var entityService = entityServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(1234, user, out IContent _, new[] { "F" }.ToHashSet());
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Denied, result);
-    }
-
-    [Test]
-    public void Access_Allowed_By_Permission()
-    {
-        // Arrange
-        var user = CreateUser(9);
-        var contentMock = new Mock<IContent>();
-        contentMock.Setup(c => c.Path).Returns("-1,1234,5678");
-        var content = contentMock.Object;
-        var contentServiceMock = new Mock<IContentService>();
-        contentServiceMock.Setup(x => x.GetById(1234)).Returns(content);
-        var contentService = contentServiceMock.Object;
-        var permissions = new EntityPermissionCollection { new(9876, 1234, new[] { "A", "F", "C" }.ToHashSet()) };
-        var permissionSet = new EntityPermissionSet(1234, permissions);
-        var userServiceMock = new Mock<IUserService>();
-        userServiceMock.Setup(x => x.GetPermissionsForPath(user, "-1,1234,5678")).Returns(permissionSet);
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        var entityService = entityServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(1234, user, out IContent _, new[] { "F" }.ToHashSet());
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Granted, result);
-    }
-
-    [Test]
-    public void Access_To_Root_By_Path()
-    {
-        // Arrange
-        var user = CreateUser();
-        var contentServiceMock = new Mock<IContentService>();
-        var contentService = contentServiceMock.Object;
-        var userServiceMock = new Mock<IUserService>();
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        var entityService = entityServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(-1, user, out IContent _);
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Granted, result);
-    }
-
-    [Test]
-    public void Access_To_Recycle_Bin_By_Path()
-    {
-        // Arrange
-        var user = CreateUser();
-        var contentServiceMock = new Mock<IContentService>();
-        var contentService = contentServiceMock.Object;
-        var userServiceMock = new Mock<IUserService>();
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        var entityService = entityServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(-20, user, out IContent _);
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Granted, result);
-    }
-
-    [Test]
-    public void No_Access_To_Recycle_Bin_By_Path()
-    {
-        // Arrange
-        var user = CreateUser(startContentId: 1234);
-        var contentServiceMock = new Mock<IContentService>();
-        var contentService = contentServiceMock.Object;
-        var userServiceMock = new Mock<IUserService>();
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        entityServiceMock.Setup(x => x.GetAllPaths(It.IsAny<UmbracoObjectTypes>(), It.IsAny<int[]>()))
-            .Returns(new[] { Mock.Of<TreeEntityPath>(entity => entity.Id == 1234 && entity.Path == "-1,1234") });
-        var entityService = entityServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(-20, user, out IContent _);
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Denied, result);
-    }
-
-    [Test]
-    public void No_Access_To_Root_By_Path()
-    {
-        // Arrange
-        var user = CreateUser(startContentId: 1234);
-
-        var contentServiceMock = new Mock<IContentService>();
-        var contentService = contentServiceMock.Object;
-        var userServiceMock = new Mock<IUserService>();
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        entityServiceMock.Setup(x => x.GetAllPaths(It.IsAny<UmbracoObjectTypes>(), It.IsAny<int[]>()))
-            .Returns(new[] { Mock.Of<TreeEntityPath>(entity => entity.Id == 1234 && entity.Path == "-1,1234") });
-        var entityService = entityServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(-1, user, out IContent _);
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Denied, result);
-    }
-
-    [Test]
-    public void Access_To_Root_By_Permission()
-    {
-        // Arrange
-        var user = CreateUser();
-
-        var userServiceMock = new Mock<IUserService>();
-        var permissions = new EntityPermissionCollection { new(9876, 1234, new[] { "A" }.ToHashSet()) };
-        var permissionSet = new EntityPermissionSet(1234, permissions);
-        userServiceMock.Setup(x => x.GetPermissionsForPath(user, "-1")).Returns(permissionSet);
-        var contentServiceMock = new Mock<IContentService>();
-        var contentService = contentServiceMock.Object;
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        var entityService = entityServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(-1, user, out IContent _, new[] { "A" }.ToHashSet());
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Granted, result);
-    }
-
-    [Test]
-    public void No_Access_To_Root_By_Permission()
-    {
-        // Arrange
-        var user = CreateUser(withUserGroup: false);
-
-        var userServiceMock = new Mock<IUserService>();
-        var permissions = new EntityPermissionCollection { new(9876, 1234, new[] { "A" }.ToHashSet()) };
-        var permissionSet = new EntityPermissionSet(1234, permissions);
-        userServiceMock.Setup(x => x.GetPermissionsForPath(user, "-1")).Returns(permissionSet);
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        var entityService = entityServiceMock.Object;
-        var contentServiceMock = new Mock<IContentService>();
-        var contentService = contentServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(-1, user, out IContent _, new[] { "B" }.ToHashSet());
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Denied, result);
-    }
-
-    [Test]
-    public void Access_To_Recycle_Bin_By_Permission()
-    {
-        // Arrange
-        var user = CreateUser();
-
-        var userServiceMock = new Mock<IUserService>();
-        var permissions = new EntityPermissionCollection { new(9876, 1234, new[] { "A" }.ToHashSet()) };
-        var permissionSet = new EntityPermissionSet(-20, permissions);
-
-        userServiceMock.Setup(x => x.GetPermissionsForPath(user, "-20")).Returns(permissionSet);
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        var entityService = entityServiceMock.Object;
-        var contentServiceMock = new Mock<IContentService>();
-        var contentService = contentServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(-20, user, out IContent _, new[] { "A" }.ToHashSet());
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Granted, result);
-    }
-
-    [Test]
-    public void No_Access_To_Recycle_Bin_By_Permission()
-    {
-        // Arrange
-        var user = CreateUser(withUserGroup: false);
-
-        var userServiceMock = new Mock<IUserService>();
-        var permissions = new EntityPermissionCollection { new(9876, 1234, new[] { "A" }.ToHashSet()) };
-        var permissionSet = new EntityPermissionSet(1234, permissions);
-        userServiceMock.Setup(x => x.GetPermissionsForPath(user, "-20")).Returns(permissionSet);
-        var userService = userServiceMock.Object;
-        var entityServiceMock = new Mock<IEntityService>();
-        var entityService = entityServiceMock.Object;
-        var contentServiceMock = new Mock<IContentService>();
-        var contentService = contentServiceMock.Object;
-        var contentPermissions = new ContentPermissions(userService, contentService, entityService, AppCaches.Disabled);
-
-        // Act
-        var result = contentPermissions.CheckPermissions(-20, user, out IContent _, new[] { "B" }.ToHashSet());
-
-        // Assert
-        Assert.AreEqual(ContentPermissions.ContentAccess.Denied, result);
-    }
-
-    private IUser CreateUser(int id = 0, int? startContentId = null, bool withUserGroup = true)
-    {
-        var builder = new UserBuilder()
-            .WithId(id)
-            .WithStartContentIds(startContentId.HasValue ? new[] { startContentId.Value } : new int[0]);
-        if (withUserGroup)
-        {
-            builder = builder
-                .AddUserGroup()
-                .WithId(1)
-                .WithName("admin")
-                .WithAlias("admin")
-                .Done();
-        }
-
-        return builder.Build();
-    }
-}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupServiceTest.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupServiceTest.cs
index 882eac15480a..17823b7cc9a1 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupServiceTest.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/ContentVersionCleanupServiceTest.cs
@@ -1,9 +1,9 @@
-using System.Collections.Generic;
 using System.Diagnostics;
-using System.Linq;
 using AutoFixture.NUnit4;
+using Microsoft.Extensions.Options;
 using Moq;
 using NUnit.Framework;
+using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Events;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Notifications;
@@ -26,7 +26,7 @@ public void PerformContentVersionCleanup_Always_RespectsDeleteRevisionsCancellat
         DateTime aDateTime,
         ContentVersionService sut)
     {
-        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
             .Returns(someHistoricVersions);
 
         eventAggregator.Setup(x => x.PublishCancelable(It.IsAny<ContentDeletingVersionsNotification>()))
@@ -58,7 +58,7 @@ public void PerformContentVersionCleanup_Always_FiresDeletedVersionsForEachDelet
         DateTime aDateTime,
         ContentVersionService sut)
     {
-        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
             .Returns(someHistoricVersions);
 
         eventAggregator
@@ -84,7 +84,7 @@ public void PerformContentVersionCleanup_Always_ReturnsReportOfDeletedItems(
         DateTime aDateTime,
         ContentVersionService sut)
     {
-        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
             .Returns(someHistoricVersions);
 
         eventAggregator
@@ -111,7 +111,7 @@ public void PerformContentVersionCleanup_Always_AdheresToCleanupPolicy(
         DateTime aDateTime,
         ContentVersionService sut)
     {
-        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
             .Returns(someHistoricVersions);
 
         eventAggregator
@@ -133,9 +133,6 @@ public void PerformContentVersionCleanup_Always_AdheresToCleanupPolicy(
         });
     }
 
-    /// <remarks>
-    ///     For v9 this just needs a rewrite, no static events, no service location etc
-    /// </remarks>
     [Test]
     [AutoMoqData]
     public void PerformContentVersionCleanup_HasVersionsToDelete_CallsDeleteOnRepositoryWithFilteredSet(
@@ -146,7 +143,7 @@ public void PerformContentVersionCleanup_HasVersionsToDelete_CallsDeleteOnReposi
         DateTime aDateTime,
         ContentVersionService sut)
     {
-        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
             .Returns(someHistoricVersions);
 
         eventAggregator
@@ -169,4 +166,118 @@ public void PerformContentVersionCleanup_HasVersionsToDelete_CallsDeleteOnReposi
             x => x.DeleteVersions(It.Is<IEnumerable<int>>(y => y.Single() == expectedId)),
             Times.Once);
     }
+
+    [Test]
+    [AutoMoqData]
+    public void PerformContentVersionCleanup_WithOverrideSmallerKeepAllDays_UsesSmallestAsCutoff(
+        [Frozen] Mock<IOptionsMonitor<ContentSettings>> contentSettings,
+        [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
+        ContentVersionService sut)
+    {
+        var asAtDate = new DateTime(2026, 3, 24, 12, 0, 0, DateTimeKind.Utc);
+
+        contentSettings.Setup(x => x.CurrentValue).Returns(new ContentSettings
+        {
+            ContentVersionCleanupPolicy = new Umbraco.Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings
+            {
+                EnableCleanup = true,
+                KeepAllVersionsNewerThanDays = 7,
+                KeepLatestVersionPerDayForDays = 0,
+            },
+        });
+
+        // Override with a smaller KeepAllVersionsNewerThanDays (2 < 7).
+        documentVersionRepository.Setup(x => x.GetCleanupPolicies())
+            .Returns(
+            [
+                new() { ContentTypeId = 1, KeepAllVersionsNewerThanDays = 2 },
+            ]);
+
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
+            .Returns(Array.Empty<ContentVersionMeta>());
+
+        sut.PerformContentVersionCleanup(asAtDate);
+
+        // The effective cutoff should be 2 days (the override's value, not the global 7).
+        DateTime expectedCutoff = asAtDate.AddDays(-2);
+        documentVersionRepository.Verify(
+            x => x.GetContentVersionsEligibleForCleanup(expectedCutoff, It.IsAny<int?>()),
+            Times.Once);
+    }
+
+    [Test]
+    [AutoMoqData]
+    public void PerformContentVersionCleanup_WithOverrideNullKeepAllDays_UsesGlobalValue(
+        [Frozen] Mock<IOptionsMonitor<ContentSettings>> contentSettings,
+        [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
+        ContentVersionService sut)
+    {
+        var asAtDate = new DateTime(2026, 3, 24, 12, 0, 0, DateTimeKind.Utc);
+
+        contentSettings.Setup(x => x.CurrentValue).Returns(new ContentSettings
+        {
+            ContentVersionCleanupPolicy = new Umbraco.Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings
+            {
+                EnableCleanup = true,
+                KeepAllVersionsNewerThanDays = 7,
+                KeepLatestVersionPerDayForDays = 0,
+            },
+        });
+
+        // Override with null KeepAllVersionsNewerThanDays — should not affect global.
+        documentVersionRepository.Setup(x => x.GetCleanupPolicies())
+            .Returns(
+            [
+                new() { ContentTypeId = 1, KeepAllVersionsNewerThanDays = null, PreventCleanup = true },
+            ]);
+
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
+            .Returns(Array.Empty<ContentVersionMeta>());
+
+        sut.PerformContentVersionCleanup(asAtDate);
+
+        // The effective cutoff should remain 7 days (the global value).
+        DateTime expectedCutoff = asAtDate.AddDays(-7);
+        documentVersionRepository.Verify(
+            x => x.GetContentVersionsEligibleForCleanup(expectedCutoff, It.IsAny<int?>()),
+            Times.Once);
+    }
+
+    [Test]
+    [AutoMoqData]
+    public void PerformContentVersionCleanup_WithMultipleOverrides_UsesSmallestKeepAllDays(
+        [Frozen] Mock<IOptionsMonitor<ContentSettings>> contentSettings,
+        [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
+        ContentVersionService sut)
+    {
+        var asAtDate = new DateTime(2026, 3, 24, 12, 0, 0, DateTimeKind.Utc);
+
+        contentSettings.Setup(x => x.CurrentValue).Returns(new ContentSettings
+        {
+            ContentVersionCleanupPolicy = new Umbraco.Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings
+            {
+                EnableCleanup = true,
+                KeepAllVersionsNewerThanDays = 7,
+                KeepLatestVersionPerDayForDays = 0,
+            },
+        });
+
+        // Multiple overrides — smallest (1) should win over global (7) and the other override (5).
+        documentVersionRepository.Setup(x => x.GetCleanupPolicies())
+            .Returns(
+            [
+                new() { ContentTypeId = 1, KeepAllVersionsNewerThanDays = 5 },
+                new() { ContentTypeId = 2, KeepAllVersionsNewerThanDays = 1 },
+            ]);
+
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
+            .Returns(Array.Empty<ContentVersionMeta>());
+
+        sut.PerformContentVersionCleanup(asAtDate);
+
+        DateTime expectedCutoff = asAtDate.AddDays(-1);
+        documentVersionRepository.Verify(
+            x => x.GetContentVersionsEligibleForCleanup(expectedCutoff, It.IsAny<int?>()),
+            Times.Once);
+    }
 }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DefaultContentVersionCleanupPolicyTest.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DefaultContentVersionCleanupPolicyTest.cs
index 8bc964ef8357..9cde01e070d6 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DefaultContentVersionCleanupPolicyTest.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DefaultContentVersionCleanupPolicyTest.cs
@@ -9,278 +9,277 @@
 using Umbraco.Cms.Tests.UnitTests.AutoFixture;
 using ContentVersionCleanupPolicySettings = Umbraco.Cms.Core.Models.ContentVersionCleanupPolicySettings;
 
-namespace Umbraco.Tests.Services
+namespace Umbraco.Tests.Services;
+
+[TestFixture]
+public class DefaultContentVersionCleanupPolicyTest
 {
-    [TestFixture]
-    public class DefaultContentVersionCleanupPolicyTest
+    [Test]
+    [AutoMoqData]
+    public void Apply_AllOlderThanKeepSettings_AllVersionsReturned(
+        [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
+        [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
+        DefaultContentVersionCleanupPolicy sut)
     {
-        [Test]
-        [AutoMoqData]
-        public void Apply_AllOlderThanKeepSettings_AllVersionsReturned(
-            [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
-            DefaultContentVersionCleanupPolicy sut)
+        var versionId = 0;
+
+        var historicItems = new List<ContentVersionMeta>
         {
-            var versionId = 0;
+            new(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+            new(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+        };
 
-            var historicItems = new List<ContentVersionMeta>
+        contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
+        {
+            ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
             {
-                new ContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
-                new ContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
-            };
+                EnableCleanup = true,
+                KeepAllVersionsNewerThanDays = 0,
+                KeepLatestVersionPerDayForDays = 0,
+            },
+        });
 
-            contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
-            {
-                ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
-                {
-                    EnableCleanup = true,
-                    KeepAllVersionsNewerThanDays = 0,
-                    KeepLatestVersionPerDayForDays = 0,
-                },
-            });
+        documentVersionRepository.Setup(x => x.GetCleanupPolicies())
+            .Returns(Array.Empty<ContentVersionCleanupPolicySettings>());
 
-            documentVersionRepository.Setup(x => x.GetCleanupPolicies())
-                .Returns(Array.Empty<ContentVersionCleanupPolicySettings>());
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
+            .Returns(historicItems);
 
-            documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
-                .Returns(historicItems);
+        var results = sut.Apply(DateTime.Today, historicItems).ToList();
 
-            var results = sut.Apply(DateTime.Today, historicItems).ToList();
+        Assert.AreEqual(2, results.Count);
+    }
 
-            Assert.AreEqual(2, results.Count);
-        }
+    [Test]
+    [AutoMoqData]
+    public void Apply_OverlappingKeepSettings_KeepAllVersionsNewerThanDaysTakesPriority(
+        [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
+        [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
+        DefaultContentVersionCleanupPolicy sut)
+    {
+        var versionId = 0;
 
-        [Test]
-        [AutoMoqData]
-        public void Apply_OverlappingKeepSettings_KeepAllVersionsNewerThanDaysTakesPriority(
-            [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
-            DefaultContentVersionCleanupPolicy sut)
+        var historicItems = new List<ContentVersionMeta>
         {
-            var versionId = 0;
+            new(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+            new(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+        };
 
-            var historicItems = new List<ContentVersionMeta>
+        contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
+        {
+            ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
             {
-                new ContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
-                new ContentVersionMeta(versionId: ++versionId, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
-            };
+                EnableCleanup = true,
+                KeepAllVersionsNewerThanDays = 2,
+                KeepLatestVersionPerDayForDays = 2,
+            },
+        });
 
-            contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
-            {
-                ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
-                {
-                    EnableCleanup = true,
-                    KeepAllVersionsNewerThanDays = 2,
-                    KeepLatestVersionPerDayForDays = 2,
-                },
-            });
+        documentVersionRepository.Setup(x => x.GetCleanupPolicies())
+            .Returns(Array.Empty<ContentVersionCleanupPolicySettings>());
 
-            documentVersionRepository.Setup(x => x.GetCleanupPolicies())
-                .Returns(Array.Empty<ContentVersionCleanupPolicySettings>());
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
+            .Returns(historicItems);
 
-            documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
-                .Returns(historicItems);
+        var results = sut.Apply(DateTime.Today, historicItems).ToList();
 
-            var results = sut.Apply(DateTime.Today, historicItems).ToList();
-
-            Assert.AreEqual(0, results.Count);
-        }
+        Assert.AreEqual(0, results.Count);
+    }
 
-        [Test]
-        [AutoMoqData]
-        public void Apply_WithinInKeepLatestPerDay_ReturnsSinglePerContentPerDay(
-            [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
-            DefaultContentVersionCleanupPolicy sut)
+    [Test]
+    [AutoMoqData]
+    public void Apply_WithinInKeepLatestPerDay_ReturnsSinglePerContentPerDay(
+        [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
+        [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
+        DefaultContentVersionCleanupPolicy sut)
+    {
+        var historicItems = new List<ContentVersionMeta>
         {
-            var historicItems = new List<ContentVersionMeta>
-            {
-                new ContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
-                new ContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
-                new ContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+            new(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+            new(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+            new(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
 
-                new ContentVersionMeta(versionId: 4, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddDays(-1).AddHours(-3), false, false, false, null),
-                new ContentVersionMeta(versionId: 5, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddDays(-1).AddHours(-2), false, false, false, null),
-                new ContentVersionMeta(versionId: 6, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddDays(-1).AddHours(-1), false, false, false, null),
+            new(versionId: 4, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddDays(-1).AddHours(-3), false, false, false, null),
+            new(versionId: 5, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddDays(-1).AddHours(-2), false, false, false, null),
+            new(versionId: 6, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddDays(-1).AddHours(-1), false, false, false, null),
 
-                // another content
-                new ContentVersionMeta(versionId: 7, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
-                new ContentVersionMeta(versionId: 8, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
-                new ContentVersionMeta(versionId: 9, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
-            };
+            // another content
+            new(versionId: 7, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+            new(versionId: 8, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+            new(versionId: 9, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+        };
 
-            contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
+        contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
+        {
+            ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
             {
-                ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
-                {
-                    EnableCleanup = true,
-                    KeepAllVersionsNewerThanDays = 0,
-                    KeepLatestVersionPerDayForDays = 3,
-                },
-            });
+                EnableCleanup = true,
+                KeepAllVersionsNewerThanDays = 0,
+                KeepLatestVersionPerDayForDays = 3,
+            },
+        });
 
-            documentVersionRepository.Setup(x => x.GetCleanupPolicies())
-                .Returns(Array.Empty<ContentVersionCleanupPolicySettings>());
+        documentVersionRepository.Setup(x => x.GetCleanupPolicies())
+            .Returns(Array.Empty<ContentVersionCleanupPolicySettings>());
 
-            documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
-                .Returns(historicItems);
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
+            .Returns(historicItems);
 
-            var results = sut.Apply(DateTime.Today, historicItems).ToList();
+        var results = sut.Apply(DateTime.Today, historicItems).ToList();
 
-            // Keep latest per day for 3 days per content type
-            // 2 content types, one of which has 2 days of entries, the other only a single day
-            Assert.Multiple(() =>
-            {
-                Assert.AreEqual(6, results.Count);
-                Assert.AreEqual(4, results.Count(x => x.ContentTypeId == 1));
-                Assert.AreEqual(2, results.Count(x => x.ContentTypeId == 2));
-                Assert.False(results.Any(x => x.VersionId == 9)); // Most recent for content type 2
-                Assert.False(results.Any(x => x.VersionId == 3)); // Most recent for content type 1 today
-                Assert.False(results.Any(x => x.VersionId == 6)); // Most recent for content type 1 yesterday
-            });
-        }
-
-        [Test]
-        [AutoMoqData]
-        public void Apply_HasOverridePolicy_RespectsPreventCleanup(
-            [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
-            DefaultContentVersionCleanupPolicy sut)
+        // Keep latest per day for 3 days per content type
+        // 2 content types, one of which has 2 days of entries, the other only a single day
+        Assert.Multiple(() =>
         {
-            var historicItems = new List<ContentVersionMeta>
-            {
-                new ContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
-                new ContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
-                new ContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+            Assert.AreEqual(6, results.Count);
+            Assert.AreEqual(4, results.Count(x => x.ContentTypeId == 1));
+            Assert.AreEqual(2, results.Count(x => x.ContentTypeId == 2));
+            Assert.False(results.Any(x => x.VersionId == 9)); // Most recent for content type 2
+            Assert.False(results.Any(x => x.VersionId == 3)); // Most recent for content type 1 today
+            Assert.False(results.Any(x => x.VersionId == 6)); // Most recent for content type 1 yesterday
+        });
+    }
 
-                // another content & type
-                new ContentVersionMeta(versionId: 4, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
-                new ContentVersionMeta(versionId: 5, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
-                new ContentVersionMeta(versionId: 6, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
-            };
+    [Test]
+    [AutoMoqData]
+    public void Apply_HasOverridePolicy_RespectsPreventCleanup(
+        [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
+        [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
+        DefaultContentVersionCleanupPolicy sut)
+    {
+        var historicItems = new List<ContentVersionMeta>
+        {
+            new(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+            new(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+            new(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
 
-            contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
+            // another content & type
+            new(versionId: 4, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+            new(versionId: 5, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+            new(versionId: 6, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+        };
+
+        contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
+        {
+            ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
             {
-                ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
-                {
-                    EnableCleanup = true,
-                    KeepAllVersionsNewerThanDays = 0,
-                    KeepLatestVersionPerDayForDays = 0,
-                },
-            });
+                EnableCleanup = true,
+                KeepAllVersionsNewerThanDays = 0,
+                KeepLatestVersionPerDayForDays = 0,
+            },
+        });
 
-            documentVersionRepository.Setup(x => x.GetCleanupPolicies())
-                .Returns(new ContentVersionCleanupPolicySettings[]
-                {
-                    new() { ContentTypeId = 2, PreventCleanup = true },
-                });
+        documentVersionRepository.Setup(x => x.GetCleanupPolicies())
+            .Returns(
+            [
+                new() { ContentTypeId = 2, PreventCleanup = true },
+            ]);
 
-            documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
-                .Returns(historicItems);
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
+            .Returns(historicItems);
 
-            var results = sut.Apply(DateTime.Today, historicItems).ToList();
+        var results = sut.Apply(DateTime.Today, historicItems).ToList();
 
-            Assert.True(results.All(x => x.ContentTypeId == 1));
-        }
+        Assert.True(results.All(x => x.ContentTypeId == 1));
+    }
 
-        [Test]
-        [AutoMoqData]
-        public void Apply_HasOverridePolicy_RespectsKeepAll(
-            [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
-            DefaultContentVersionCleanupPolicy sut)
+    [Test]
+    [AutoMoqData]
+    public void Apply_HasOverridePolicy_RespectsKeepAll(
+        [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
+        [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
+        DefaultContentVersionCleanupPolicy sut)
+    {
+        var historicItems = new List<ContentVersionMeta>
         {
-            var historicItems = new List<ContentVersionMeta>
-            {
-                new ContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
-                new ContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
-                new ContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+            new(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+            new(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+            new(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
 
-                // another content & type
-                new ContentVersionMeta(versionId: 4, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
-                new ContentVersionMeta(versionId: 5, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
-                new ContentVersionMeta(versionId: 6, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
-            };
+            // another content & type
+            new(versionId: 4, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+            new(versionId: 5, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+            new(versionId: 6, contentId: 2, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+        };
 
-            contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
+        contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
+        {
+            ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
             {
-                ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
-                {
-                    EnableCleanup = true,
-                    KeepAllVersionsNewerThanDays = 0,
-                    KeepLatestVersionPerDayForDays = 0,
-                },
+                EnableCleanup = true,
+                KeepAllVersionsNewerThanDays = 0,
+                KeepLatestVersionPerDayForDays = 0,
+            },
+        });
+
+        documentVersionRepository.Setup(x => x.GetCleanupPolicies())
+            .Returns(new ContentVersionCleanupPolicySettings[]
+            {
+                new() { ContentTypeId = 2, PreventCleanup = false, KeepAllVersionsNewerThanDays = 3 },
             });
 
-            documentVersionRepository.Setup(x => x.GetCleanupPolicies())
-                .Returns(new ContentVersionCleanupPolicySettings[]
-                {
-                    new() { ContentTypeId = 2, PreventCleanup = false, KeepAllVersionsNewerThanDays = 3 },
-                });
-
-            documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
-                .Returns(historicItems);
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
+            .Returns(historicItems);
 
-            var results = sut.Apply(DateTime.Today, historicItems).ToList();
+        var results = sut.Apply(DateTime.Today, historicItems).ToList();
 
-            Assert.True(results.All(x => x.ContentTypeId == 1));
-        }
+        Assert.True(results.All(x => x.ContentTypeId == 1));
+    }
 
-        [Test]
-        [AutoMoqData]
-        public void Apply_HasOverridePolicy_RespectsKeepLatest(
-            [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
-            [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
-            DefaultContentVersionCleanupPolicy sut)
+    [Test]
+    [AutoMoqData]
+    public void Apply_HasOverridePolicy_RespectsKeepLatest(
+        [Frozen] Mock<IDocumentVersionRepository> documentVersionRepository,
+        [Frozen] Mock<IOptions<ContentSettings>> contentSettings,
+        DefaultContentVersionCleanupPolicy sut)
+    {
+        var historicItems = new List<ContentVersionMeta>
+        {
+            new(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+            new(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+            new(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+
+            // another content
+            new(versionId: 4, contentId: 2, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+            new(versionId: 5, contentId: 2, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+            new(versionId: 6, contentId: 2, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+
+            // another content & type
+            new(versionId: 7, contentId: 3, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
+            new(versionId: 8, contentId: 3, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
+            new(versionId: 9, contentId: 3, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
+        };
+
+        contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
         {
-            var historicItems = new List<ContentVersionMeta>
+            ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
             {
-                new ContentVersionMeta(versionId: 1, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
-                new ContentVersionMeta(versionId: 2, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
-                new ContentVersionMeta(versionId: 3, contentId: 1, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
-
-                // another content
-                new ContentVersionMeta(versionId: 4, contentId: 2, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
-                new ContentVersionMeta(versionId: 5, contentId: 2, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
-                new ContentVersionMeta(versionId: 6, contentId: 2, contentTypeId: 1, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
-
-                // another content & type
-                new ContentVersionMeta(versionId: 7, contentId: 3, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-3), false, false, false, null),
-                new ContentVersionMeta(versionId: 8, contentId: 3, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-2), false, false, false, null),
-                new ContentVersionMeta(versionId: 9, contentId: 3, contentTypeId: 2, -1, versionDate: DateTime.Today.AddHours(-1), false, false, false, null),
-            };
-
-            contentSettings.Setup(x => x.Value).Returns(new ContentSettings()
+                EnableCleanup = true,
+                KeepAllVersionsNewerThanDays = 0,
+                KeepLatestVersionPerDayForDays = 0,
+            },
+        });
+
+        documentVersionRepository.Setup(x => x.GetCleanupPolicies())
+            .Returns(new ContentVersionCleanupPolicySettings[]
             {
-                ContentVersionCleanupPolicy = new Cms.Core.Configuration.Models.ContentVersionCleanupPolicySettings()
-                {
-                    EnableCleanup = true,
-                    KeepAllVersionsNewerThanDays = 0,
-                    KeepLatestVersionPerDayForDays = 0,
-                },
+                new() { ContentTypeId = 2, PreventCleanup = false, KeepLatestVersionPerDayForDays = 3 },
             });
 
-            documentVersionRepository.Setup(x => x.GetCleanupPolicies())
-                .Returns(new ContentVersionCleanupPolicySettings[]
-                {
-                    new() { ContentTypeId = 2, PreventCleanup = false, KeepLatestVersionPerDayForDays = 3 },
-                });
+        documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup(It.IsAny<DateTime>(), It.IsAny<int?>()))
+            .Returns(historicItems);
 
-            documentVersionRepository.Setup(x => x.GetContentVersionsEligibleForCleanup())
-                .Returns(historicItems);
+        var results = sut.Apply(DateTime.Today, historicItems).ToList();
 
-            var results = sut.Apply(DateTime.Today, historicItems).ToList();
-
-            // By default no historic versions are kept
-            // Override policy for content type 2 keeps latest per day for 3 days, no versions retained for content type with id 1
-            // There were 3 entries for content type 2 all on the same day
-            // version id 9 is most recent for content type 2, and should be filtered, all the rest should be present.
-            Assert.Multiple(() =>
-            {
-                Assert.AreEqual(8, results.Count);
-                Assert.AreEqual(2, results.Count(x => x.ContentTypeId == 2));
-                Assert.False(results.Any(x => x.VersionId == 9));
-            });
-        }
+        // By default no historic versions are kept
+        // Override policy for content type 2 keeps latest per day for 3 days, no versions retained for content type with id 1
+        // There were 3 entries for content type 2 all on the same day
+        // version id 9 is most recent for content type 2, and should be filtered, all the rest should be present.
+        Assert.Multiple(() =>
+        {
+            Assert.AreEqual(8, results.Count);
+            Assert.AreEqual(2, results.Count(x => x.ContentTypeId == 2));
+            Assert.False(results.Any(x => x.VersionId == 9));
+        });
     }
 }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DocumentUrlServiceTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DocumentUrlServiceTests.cs
index 51ec9651101f..d7a9f956ebb4 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DocumentUrlServiceTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Core/Services/DocumentUrlServiceTests.cs
@@ -31,7 +31,7 @@ public void ConvertToCacheModel_Converts_Single_Document_With_Single_Segment_To_
                 DocumentKey = documentKey,
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = 1,
+                LanguageId = 1,
                 UrlSegment = "test-segment",
             },
         };
@@ -57,7 +57,7 @@ public void ConvertToCacheModel_Converts_Multiple_Documents_With_Single_Segment_
                 DocumentKey = documentKey1,
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = 1,
+                LanguageId = 1,
                 UrlSegment = "test-segment",
             },
             new()
@@ -65,7 +65,7 @@ public void ConvertToCacheModel_Converts_Multiple_Documents_With_Single_Segment_
                 DocumentKey = documentKey2,
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = 1,
+                LanguageId = 1,
                 UrlSegment = "test-segment-2",
             },
         };
@@ -95,7 +95,7 @@ public void ConvertToCacheModel_Converts_Single_Document_With_Multiple_Segments_
                 DocumentKey = documentKey,
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = 1,
+                LanguageId = 1,
                 UrlSegment = "test-segment",
             },
             new()
@@ -103,7 +103,7 @@ public void ConvertToCacheModel_Converts_Single_Document_With_Multiple_Segments_
                 DocumentKey = documentKey,
                 IsDraft = false,
                 IsPrimary = false,
-                NullableLanguageId = 1,
+                LanguageId = 1,
                 UrlSegment = "test-segment-2",
             },
         };
@@ -128,7 +128,7 @@ public void ConvertToCacheModel_Performance_Test()
                 DocumentKey = Guid.NewGuid(),
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = 1,
+                LanguageId = 1,
                 UrlSegment = $"test-segment-{x + 1}",
             });
         var cacheModels = DocumentUrlService.ConvertToCacheModel(segments).ToList();
@@ -152,7 +152,7 @@ public void ConvertToCacheModel_Handles_Null_LanguageId_For_Invariant_Content()
                 DocumentKey = documentKey,
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = null, // Invariant content uses NULL
+                LanguageId = null, // Invariant content uses NULL
                 UrlSegment = "test-segment",
             },
         };
@@ -178,7 +178,7 @@ public void ConvertToCacheModel_Handles_Mixed_Invariant_And_Variant_Content()
                 DocumentKey = invariantDocKey,
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = null, // Invariant content
+                LanguageId = null, // Invariant content
                 UrlSegment = "invariant-segment",
             },
             new()
@@ -186,7 +186,7 @@ public void ConvertToCacheModel_Handles_Mixed_Invariant_And_Variant_Content()
                 DocumentKey = variantDocKey,
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = 1, // Variant content
+                LanguageId = 1, // Variant content
                 UrlSegment = "variant-segment",
             },
         };
@@ -363,12 +363,12 @@ public async Task CreateOrUpdateUrlSegmentsAsync_VariantContent_Stores_PerLangua
 
         // Verify all saved segments have specific language IDs (not NULL)
         Assert.That(
-            savedSegments!.All(s => s.NullableLanguageId.HasValue),
+            savedSegments!.All(s => s.LanguageId.HasValue),
             Is.True,
             "Variant content should have specific LanguageId values (not NULL)");
 
         // Should have segments for both languages
-        var languageIds = savedSegments.Select(s => s.NullableLanguageId).Distinct().ToList();
+        var languageIds = savedSegments.Select(s => s.LanguageId).Distinct().ToList();
         Assert.That(languageIds, Does.Contain(1), "Should have segments for en-US (language ID 1)");
         Assert.That(languageIds, Does.Contain(2), "Should have segments for fr-FR (language ID 2)");
     }
@@ -407,7 +407,7 @@ public async Task CreateOrUpdateUrlSegmentsAsync_InvariantContent_WithIdenticalS
 
         // Verify all saved segments have NULL language ID
         Assert.That(
-            savedSegments!.All(s => s.NullableLanguageId is null),
+            savedSegments!.All(s => s.LanguageId is null),
             Is.True,
             "Invariant content with identical segments should have NULL LanguageId");
     }
@@ -451,12 +451,12 @@ public async Task CreateOrUpdateUrlSegmentsAsync_InvariantContent_WithDifferentS
 
         // Verify all saved segments have specific language IDs (not NULL)
         Assert.That(
-            savedSegments!.All(s => s.NullableLanguageId.HasValue),
+            savedSegments!.All(s => s.LanguageId.HasValue),
             Is.True,
             "Invariant content with different segments should have specific LanguageId values (not NULL)");
 
         // Should have segments for both languages
-        var languageIds = savedSegments.Select(s => s.NullableLanguageId).Distinct().ToList();
+        var languageIds = savedSegments.Select(s => s.LanguageId).Distinct().ToList();
         Assert.That(languageIds, Does.Contain(1), "Should have segments for en-US (language ID 1)");
         Assert.That(languageIds, Does.Contain(2), "Should have segments for fr-FR (language ID 2)");
     }
@@ -493,7 +493,7 @@ public async Task CreateOrUpdateUrlSegmentsAsync_InvariantContent_WithSingleLang
 
         // Verify all saved segments have NULL language ID (single language optimization)
         Assert.That(
-            savedSegments!.All(s => s.NullableLanguageId is null),
+            savedSegments!.All(s => s.LanguageId is null),
             Is.True,
             "Invariant content with single language should have NULL LanguageId");
     }
@@ -647,7 +647,7 @@ public async Task GetUrlSegment_InvariantContent_WithEmptyCulture_Returns_Segmen
                 DocumentKey = documentKey,
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = null, // Invariant content
+                LanguageId = null, // Invariant content
                 UrlSegment = "invariant-page",
             },
         };
@@ -675,7 +675,7 @@ public async Task GetUrlSegment_VariantContent_WithCulture_Returns_Segment()
                 DocumentKey = documentKey,
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = 1,
+                LanguageId = 1,
                 UrlSegment = "english-page",
             },
         };
@@ -704,7 +704,7 @@ public async Task GetUrlSegment_InvariantContent_WithValidCulture_Falls_Back_To_
                 DocumentKey = documentKey,
                 IsDraft = false,
                 IsPrimary = true,
-                NullableLanguageId = null, // Stored as invariant
+                LanguageId = null, // Stored as invariant
                 UrlSegment = "invariant-page",
             },
         };
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/DistributedLocking/EFCoreScopeAccessorTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/DistributedLocking/EFCoreScopeAccessorTests.cs
index 242b45eb7776..60ec97fecee1 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/DistributedLocking/EFCoreScopeAccessorTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/DistributedLocking/EFCoreScopeAccessorTests.cs
@@ -27,7 +27,7 @@ private static EFCoreScopeAccessor<UmbracoDbContext> CreateAccessor(
     public void HasBridgedAmbientScope_NoScopeOnStack_ReturnsTrue()
     {
         var efScopeStack = new Mock<IAmbientEFCoreScopeStack<UmbracoDbContext>>();
-        efScopeStack.Setup(x => x.AmbientScope).Returns((IEfCoreScope<UmbracoDbContext>?)null);
+        efScopeStack.Setup(x => x.AmbientScope).Returns((IEFCoreScope<UmbracoDbContext>?)null);
 
         var accessor = CreateAccessor(efScopeStack.Object, Mock.Of<IAmbientScopeStack>());
 
@@ -37,14 +37,14 @@ public void HasBridgedAmbientScope_NoScopeOnStack_ReturnsTrue()
     [Test]
     public void HasBridgedAmbientScope_NonEFCoreScopeOnStack_ReturnsTrue()
     {
-        // A mock of IEfCoreScope<T> is not an EFCoreScope<T> concrete type,
+        // A mock of IEFCoreScope<T> is not an EFCoreScope<T> concrete type,
         // so the type pattern match `is EFCoreScope<T> { IsBridgeScope: false }` fails.
         // This covers the bridge-scope-on-stack case (bridge scopes are EFCoreScope<T>
         // instances with IsBridgeScope: true, but in terms of the type check they would
         // also be EFCoreScope<T> — the mock here acts as a stand-in for the "not a real
         // non-bridge scope" scenario).
         var efScopeStack = new Mock<IAmbientEFCoreScopeStack<UmbracoDbContext>>();
-        efScopeStack.Setup(x => x.AmbientScope).Returns(Mock.Of<IEfCoreScope<UmbracoDbContext>>());
+        efScopeStack.Setup(x => x.AmbientScope).Returns(Mock.Of<IEFCoreScope<UmbracoDbContext>>());
 
         var accessor = CreateAccessor(efScopeStack.Object, Mock.Of<IAmbientScopeStack>());
 
@@ -65,7 +65,7 @@ public void HasBridgedAmbientScope_WhenNpocoScopeIsActive_DoesNotTriggerBridgeSc
         //   - HasBridgedAmbientScope must return true without throwing
 
         var efScopeStack = new Mock<IAmbientEFCoreScopeStack<UmbracoDbContext>>();
-        efScopeStack.Setup(x => x.AmbientScope).Returns((IEfCoreScope<UmbracoDbContext>?)null);
+        efScopeStack.Setup(x => x.AmbientScope).Returns((IEFCoreScope<UmbracoDbContext>?)null);
 
         var npocoScopeStack = new Mock<IAmbientScopeStack>();
         npocoScopeStack.Setup(x => x.AmbientScope).Returns(Mock.Of<IScope>());
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Examine/ContentValueSetBuilderTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Examine/ContentValueSetBuilderTests.cs
new file mode 100644
index 000000000000..a47fdfc28d94
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Examine/ContentValueSetBuilderTests.cs
@@ -0,0 +1,484 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+using Examine;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Membership;
+using Umbraco.Cms.Core.PropertyEditors;
+using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Strings;
+using Umbraco.Cms.Infrastructure.Examine;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.Examine;
+
+[TestFixture]
+public class ContentValueSetBuilderTests
+{
+    private const string DefaultCulture = "en-US";
+    private Mock<IUserService> _userService = null!;
+    private Mock<ICoreScopeProvider> _scopeProvider = null!;
+#pragma warning disable CS0618 // Type or member is obsolete
+    private Mock<ILocalizationService> _localizationService = null!;
+#pragma warning restore CS0618 // Type or member is obsolete
+    private Mock<IContentTypeService> _contentTypeService = null!;
+    private Mock<IDocumentUrlService> _documentUrlService = null!;
+    private Mock<ILanguageService> _languageService = null!;
+    private Mock<IShortStringHelper> _shortStringHelper = null!;
+    private UrlSegmentProviderCollection _urlSegmentProviders = null!;
+    private PropertyEditorCollection _propertyEditors = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _userService = new Mock<IUserService>();
+        SetupUserProfiles((10, "Alice"), (20, "Bob"));
+        _scopeProvider = new Mock<ICoreScopeProvider>();
+        _scopeProvider
+            .Setup(x => x.CreateCoreScope(
+                It.IsAny<System.Data.IsolationLevel>(),
+                It.IsAny<RepositoryCacheMode>(),
+                It.IsAny<IEventDispatcher?>(),
+                It.IsAny<IScopedNotificationPublisher?>(),
+                It.IsAny<bool?>(),
+                It.IsAny<bool>(),
+                It.IsAny<bool>()))
+            .Returns(Mock.Of<ICoreScope>());
+#pragma warning disable CS0618 // Type or member is obsolete
+        _localizationService = new Mock<ILocalizationService>();
+_localizationService.Setup(x => x.GetDefaultLanguageIsoCode()).Returns(DefaultCulture);
+#pragma warning restore CS0618 // Type or member is obsolete
+        _contentTypeService = new Mock<IContentTypeService>();
+        _contentTypeService.Setup(x => x.GetAll()).Returns(Array.Empty<IContentType>());
+        _documentUrlService = new Mock<IDocumentUrlService>();
+        _documentUrlService.Setup(x => x.IsInitialized).Returns(true);
+        _languageService = new Mock<ILanguageService>();
+        _languageService.Setup(x => x.GetDefaultIsoCodeAsync()).ReturnsAsync(DefaultCulture);
+        _shortStringHelper = new Mock<IShortStringHelper>();
+        _urlSegmentProviders = new UrlSegmentProviderCollection(() => Array.Empty<IUrlSegmentProvider>());
+        _propertyEditors = new PropertyEditorCollection(new DataEditorCollection(() => Array.Empty<IDataEditor>()));
+    }
+
+    private void SetupUserProfiles(params (int Id, string Name)[] users)
+    {
+        var userMocks = users.Select(u =>
+        {
+            var mock = new Mock<IUser>();
+            mock.Setup(x => x.Id).Returns(u.Id);
+            mock.Setup(x => x.Name).Returns(u.Name);
+            return mock.Object;
+        }).ToArray();
+        _userService
+            .Setup(x => x.GetUsersById(It.IsAny<int[]>()))
+            .Returns<int[]>(ids => userMocks.Where(u => ids.Contains(u.Id)).ToArray());
+    }
+
+    private ContentValueSetBuilder CreateBuilder(bool publishedValuesOnly = false) =>
+        new(
+            _propertyEditors,
+            _urlSegmentProviders,
+            _userService.Object,
+            _shortStringHelper.Object,
+            _scopeProvider.Object,
+            publishedValuesOnly,
+            _localizationService.Object,
+            _contentTypeService.Object,
+            NullLogger<ContentValueSetBuilder>.Instance,
+            _documentUrlService.Object,
+            _languageService.Object);
+
+    private static Mock<IContent> CreateContentMock(
+        int id = 1,
+        Guid? key = null,
+        string name = "Test Content",
+        string? publishName = "Test Content",
+        bool published = true,
+        int parentId = -1,
+        int level = 1,
+        int creatorId = 10,
+        int writerId = 20,
+        int sortOrder = 0,
+        string path = "-1,1",
+        int? templateId = null,
+        string contentTypeAlias = "testType",
+        int contentTypeId = 100,
+        Guid? contentTypeKey = null,
+        string? icon = "icon-document",
+        ContentVariation variation = ContentVariation.Nothing)
+    {
+        var contentType = Mock.Of<ISimpleContentType>(ct =>
+            ct.Id == contentTypeId &&
+            ct.Key == (contentTypeKey ?? Guid.NewGuid()) &&
+            ct.Alias == contentTypeAlias &&
+            ct.Icon == icon &&
+            ct.Variations == variation);
+        var content = new Mock<IContent>();
+        content.Setup(c => c.Id).Returns(id);
+        content.Setup(c => c.Key).Returns(key ?? Guid.NewGuid());
+        content.Setup(c => c.Name).Returns(name);
+        content.Setup(c => c.PublishName).Returns(publishName);
+        content.Setup(c => c.Published).Returns(published);
+        content.Setup(c => c.ParentId).Returns(parentId);
+        content.Setup(c => c.Level).Returns(level);
+        content.Setup(c => c.CreatorId).Returns(creatorId);
+        content.Setup(c => c.WriterId).Returns(writerId);
+        content.Setup(c => c.SortOrder).Returns(sortOrder);
+        content.Setup(c => c.CreateDate).Returns(new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc));
+        content.Setup(c => c.UpdateDate).Returns(new DateTime(2024, 6, 1, 0, 0, 0, DateTimeKind.Utc));
+        content.Setup(c => c.Path).Returns(path);
+        content.Setup(c => c.TemplateId).Returns(templateId);
+        content.Setup(c => c.ContentType).Returns(contentType);
+        content.Setup(c => c.Properties).Returns(new global::Umbraco.Cms.Core.Models.PropertyCollection());
+        content.Setup(c => c.AvailableCultures).Returns(Array.Empty<string>());
+        return content;
+    }
+
+    private static object? GetSingleValue(ValueSet valueSet, string fieldName)
+    {
+        Assert.That(valueSet.Values.ContainsKey(fieldName), Is.True, $"Field '{fieldName}' not found in ValueSet");
+        return valueSet.Values[fieldName].FirstOrDefault();
+    }
+
+    [Test]
+    public void GetValueSets_Returns_ValueSet_For_Single_Content()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock();
+        var results = builder.GetValueSets(content.Object).ToList();
+        Assert.That(results, Has.Count.EqualTo(1));
+    }
+
+    [Test]
+    public void GetValueSets_Returns_ValueSet_Per_Content_Item()
+    {
+        var builder = CreateBuilder();
+        var content1 = CreateContentMock(id: 1, path: "-1,1");
+        var content2 = CreateContentMock(id: 2, path: "-1,2");
+        var content3 = CreateContentMock(id: 3, path: "-1,3");
+        var results = builder.GetValueSets(content1.Object, content2.Object, content3.Object).ToList();
+        Assert.That(results, Has.Count.EqualTo(3));
+    }
+
+    [Test]
+    public void GetValueSets_Sets_Correct_ValueSet_Id_And_Category()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock(id: 42, contentTypeAlias: "blogPost");
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Id, Is.EqualTo("42"));
+            Assert.That(result.Category, Is.EqualTo(IndexTypes.Content));
+            Assert.That(result.ItemType, Is.EqualTo("blogPost"));
+        });
+    }
+
+    [Test]
+    public void GetValueSets_Populates_Basic_Fields()
+    {
+        var contentKey = Guid.NewGuid();
+        var builder = CreateBuilder();
+        var content = CreateContentMock(
+            id: 10,
+            key: contentKey,
+            parentId: 5,
+            level: 3,
+            creatorId: 10,
+            writerId: 20,
+            sortOrder: 7,
+            path: "-1,5,10",
+            templateId: 99,
+            icon: "icon-blog");
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.Multiple(() =>
+        {
+            Assert.That(GetSingleValue(result, "id"), Is.EqualTo(10));
+            Assert.That(GetSingleValue(result, UmbracoExamineFieldNames.NodeKeyFieldName), Is.EqualTo(contentKey));
+            Assert.That(GetSingleValue(result, "parentID"), Is.EqualTo(5));
+            Assert.That(GetSingleValue(result, "level"), Is.EqualTo(3));
+            Assert.That(GetSingleValue(result, "creatorID"), Is.EqualTo(10));
+            Assert.That(GetSingleValue(result, "writerID"), Is.EqualTo(20));
+            Assert.That(GetSingleValue(result, "sortOrder"), Is.EqualTo(7));
+            Assert.That(GetSingleValue(result, "path"), Is.EqualTo("-1,5,10"));
+            Assert.That(GetSingleValue(result, "templateID"), Is.EqualTo(99));
+            Assert.That(GetSingleValue(result, "icon"), Is.EqualTo("icon-blog"));
+        });
+    }
+
+    [Test]
+    public void GetValueSets_Sets_ParentId_To_Minus1_For_Root_Content()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock(level: 1, parentId: -1);
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, "parentID"), Is.EqualTo(-1));
+    }
+
+    [Test]
+    public void GetValueSets_Sets_ParentId_From_Content_When_Level_Greater_Than_1()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock(level: 2, parentId: 42);
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, "parentID"), Is.EqualTo(42));
+    }
+    [Test]
+    public void GetValueSets_Sets_TemplateId_To_Zero_When_Null()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock(templateId: null);
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, "templateID"), Is.EqualTo(0));
+    }
+
+    [Test]
+    public void GetValueSets_Sets_Published_Yes_When_Published()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock(published: true);
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, UmbracoExamineFieldNames.PublishedFieldName), Is.EqualTo("y"));
+    }
+
+    [Test]
+    public void GetValueSets_Sets_Published_No_When_Unpublished()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock(published: false);
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, UmbracoExamineFieldNames.PublishedFieldName), Is.EqualTo("n"));
+    }
+
+    [Test]
+    public void GetValueSets_Uses_Name_When_Not_PublishedValuesOnly()
+    {
+        var builder = CreateBuilder(publishedValuesOnly: false);
+        var content = CreateContentMock(name: "Draft Name", publishName: "Published Name");
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, UmbracoExamineFieldNames.NodeNameFieldName), Is.EqualTo("Draft Name"));
+    }
+
+    [Test]
+    public void GetValueSets_Uses_PublishName_When_PublishedValuesOnly()
+    {
+        var builder = CreateBuilder(publishedValuesOnly: true);
+        var content = CreateContentMock(name: "Draft Name", publishName: "Published Name");
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, UmbracoExamineFieldNames.NodeNameFieldName), Is.EqualTo("Published Name"));
+    }
+
+    [Test]
+    public void GetValueSets_Resolves_Creator_And_Writer_Names()
+    {
+        SetupUserProfiles((10, "Alice"), (20, "Bob"));
+        var builder = CreateBuilder();
+        var content = CreateContentMock(creatorId: 10, writerId: 20);
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.Multiple(() =>
+        {
+            Assert.That(GetSingleValue(result, "creatorName"), Is.EqualTo("Alice"));
+            Assert.That(GetSingleValue(result, "writerName"), Is.EqualTo("Bob"));
+        });
+    }
+
+    [Test]
+    public void GetValueSets_Uses_QuestionMarks_For_Unknown_User_Profiles()
+    {
+        _userService
+            .Setup(x => x.GetUsersById(It.IsAny<int[]>()))
+            .Returns(Array.Empty<IUser>());
+        var builder = CreateBuilder();
+        var content = CreateContentMock(creatorId: 999, writerId: 888);
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.Multiple(() =>
+        {
+            Assert.That(GetSingleValue(result, "creatorName"), Is.EqualTo("??"));
+            Assert.That(GetSingleValue(result, "writerName"), Is.EqualTo("??"));
+        });
+    }
+
+    [Test]
+    public void GetValueSets_Sets_VariesByCulture_No_For_Invariant_Content()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock(variation: ContentVariation.Nothing);
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, UmbracoExamineFieldNames.VariesByCultureFieldName), Is.EqualTo("n"));
+    }
+
+    [Test]
+    public void GetValueSets_Sets_VariesByCulture_Yes_For_Variant_Content()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock(variation: ContentVariation.Culture);
+        content.Setup(c => c.AvailableCultures).Returns(new[] { "en-US" });
+        content.Setup(c => c.IsCulturePublished("en-US")).Returns(true);
+        content.Setup(c => c.GetCultureName("en-US")).Returns("English Name");
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, UmbracoExamineFieldNames.VariesByCultureFieldName), Is.EqualTo("y"));
+    }
+
+    [Test]
+    public void GetValueSets_Adds_Culture_Specific_Fields_For_Variant_Content()
+    {
+        _documentUrlService.Setup(x => x.GetUrlSegment(It.IsAny<Guid>(), "en-US", false)).Returns("english-page");
+        _documentUrlService.Setup(x => x.GetUrlSegment(It.IsAny<Guid>(), "fr-FR", false)).Returns("page-francaise");
+        var builder = CreateBuilder(publishedValuesOnly: false);
+        var content = CreateContentMock(variation: ContentVariation.Culture);
+        content.Setup(c => c.AvailableCultures).Returns(new[] { "en-US", "fr-FR" });
+        content.Setup(c => c.IsCulturePublished("en-US")).Returns(true);
+        content.Setup(c => c.IsCulturePublished("fr-FR")).Returns(false);
+        content.Setup(c => c.GetCultureName("en-US")).Returns("English Name");
+        content.Setup(c => c.GetCultureName("fr-FR")).Returns("Nom Français");
+        content.Setup(c => c.GetUpdateDate("en-US")).Returns(new DateTime(2024, 3, 1, 0, 0, 0, DateTimeKind.Utc));
+        content.Setup(c => c.GetUpdateDate("fr-FR")).Returns(new DateTime(2024, 4, 1, 0, 0, 0, DateTimeKind.Utc));
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.Multiple(() =>
+        {
+            // URL segments per culture
+            Assert.That(GetSingleValue(result, "urlName_en-us"), Is.EqualTo("english-page"));
+            Assert.That(GetSingleValue(result, "urlName_fr-fr"), Is.EqualTo("page-francaise"));
+            // Node names per culture
+            Assert.That(GetSingleValue(result, "nodeName_en-us"), Is.EqualTo("English Name"));
+            Assert.That(GetSingleValue(result, "nodeName_fr-fr"), Is.EqualTo("Nom Français"));
+            // Published state per culture
+            Assert.That(GetSingleValue(result, UmbracoExamineFieldNames.PublishedFieldName + "_en-us"), Is.EqualTo("y"));
+            Assert.That(GetSingleValue(result, UmbracoExamineFieldNames.PublishedFieldName + "_fr-fr"), Is.EqualTo("n"));
+            // Update dates per culture
+            Assert.That(GetSingleValue(result, "updateDate_en-us"), Is.EqualTo(new DateTime(2024, 3, 1, 0, 0, 0, DateTimeKind.Utc)));
+            Assert.That(GetSingleValue(result, "updateDate_fr-fr"), Is.EqualTo(new DateTime(2024, 4, 1, 0, 0, 0, DateTimeKind.Utc)));
+        });
+    }
+
+    [Test]
+    public void GetValueSets_Uses_PublishName_For_Variant_When_PublishedValuesOnly()
+    {
+        var builder = CreateBuilder(publishedValuesOnly: true);
+        var content = CreateContentMock(variation: ContentVariation.Culture);
+        content.Setup(c => c.AvailableCultures).Returns(new[] { "en-US" });
+        content.Setup(c => c.IsCulturePublished("en-US")).Returns(true);
+        content.Setup(c => c.GetCultureName("en-US")).Returns("Draft Name");
+        content.Setup(c => c.GetPublishName("en-US")).Returns("Published Name");
+        content.Setup(c => c.GetPublishDate("en-US")).Returns(new DateTime(2024, 5, 1, 0, 0, 0, DateTimeKind.Utc));
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.Multiple(() =>
+        {
+            Assert.That(GetSingleValue(result, "nodeName_en-us"), Is.EqualTo("Published Name"));
+            Assert.That(GetSingleValue(result, "updateDate_en-us"), Is.EqualTo(new DateTime(2024, 5, 1, 0, 0, 0, DateTimeKind.Utc)));
+        });
+    }
+
+    [Test]
+    public void GetValueSets_Uses_DocumentUrlService_When_Initialized()
+    {
+        var contentKey = Guid.NewGuid();
+        _documentUrlService.Setup(x => x.IsInitialized).Returns(true);
+        _documentUrlService.Setup(x => x.GetUrlSegment(contentKey, DefaultCulture, false)).Returns("cached-url-segment");
+        var builder = CreateBuilder();
+        var content = CreateContentMock(key: contentKey);
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, "urlName"), Is.EqualTo("cached-url-segment"));
+        _documentUrlService.Verify(x => x.GetUrlSegment(contentKey, DefaultCulture, false), Times.Once);
+    }
+    [Test]
+    public void GetValueSets_Falls_Back_To_Content_Extension_When_DocumentUrlService_Not_Initialized()
+    {
+        _documentUrlService.Setup(x => x.IsInitialized).Returns(false);
+        var urlSegmentProvider = new Mock<IUrlSegmentProvider>();
+        urlSegmentProvider
+            .Setup(x => x.GetUrlSegment(It.IsAny<IContentBase>(), It.IsAny<bool>(), It.IsAny<string?>()))
+            .Returns("computed-url-segment");
+        _urlSegmentProviders = new UrlSegmentProviderCollection(() => new[] { urlSegmentProvider.Object });
+        var builder = CreateBuilder();
+        var content = CreateContentMock(name: "Test Page");
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, "urlName"), Is.EqualTo("computed-url-segment"));
+        _documentUrlService.Verify(x => x.GetUrlSegment(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Never);
+    }
+
+    [Test]
+    public void GetValueSets_Does_Not_Throw_When_DocumentUrlService_Not_Initialized()
+    {
+        _documentUrlService.Setup(x => x.IsInitialized).Returns(false);
+        _documentUrlService
+            .Setup(x => x.GetUrlSegment(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<bool>()))
+            .Throws(new InvalidOperationException("The service needs to be initialized before it can be used."));
+        var builder = CreateBuilder();
+        var content = CreateContentMock();
+        Assert.DoesNotThrow(() => builder.GetValueSets(content.Object).ToList());
+    }
+
+    [Test]
+    public void GetValueSets_Uses_DocumentUrlService_For_Variant_Cultures_When_Initialized()
+    {
+        var contentKey = Guid.NewGuid();
+        _documentUrlService.Setup(x => x.IsInitialized).Returns(true);
+        _documentUrlService.Setup(x => x.GetUrlSegment(contentKey, "en-US", false)).Returns("english-url");
+        _documentUrlService.Setup(x => x.GetUrlSegment(contentKey, "de-DE", false)).Returns("german-url");
+        var builder = CreateBuilder();
+        var content = CreateContentMock(key: contentKey, variation: ContentVariation.Culture);
+        content.Setup(c => c.AvailableCultures).Returns(new[] { "en-US", "de-DE" });
+        content.Setup(c => c.IsCulturePublished(It.IsAny<string>())).Returns(true);
+        content.Setup(c => c.GetCultureName(It.IsAny<string>())).Returns("Name");
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.Multiple(() =>
+        {
+            Assert.That(GetSingleValue(result, "urlName_en-us"), Is.EqualTo("english-url"));
+            Assert.That(GetSingleValue(result, "urlName_de-de"), Is.EqualTo("german-url"));
+        });
+        // en-US is called twice: once for the invariant urlName (using defaultCulture) and once for the variant urlName_en-us
+        _documentUrlService.Verify(x => x.GetUrlSegment(contentKey, "en-US", false), Times.Exactly(2));
+        _documentUrlService.Verify(x => x.GetUrlSegment(contentKey, "de-DE", false), Times.Once);
+    }
+
+    [Test]
+    public void GetValueSets_Falls_Back_For_Variant_Cultures_When_DocumentUrlService_Not_Initialized()
+    {
+        _documentUrlService.Setup(x => x.IsInitialized).Returns(false);
+        var urlSegmentProvider = new Mock<IUrlSegmentProvider>();
+        urlSegmentProvider
+            .Setup(x => x.GetUrlSegment(It.IsAny<IContentBase>(), It.IsAny<bool>(), "en-US"))
+            .Returns("fallback-english");
+        urlSegmentProvider
+            .Setup(x => x.GetUrlSegment(It.IsAny<IContentBase>(), It.IsAny<bool>(), "fr-FR"))
+            .Returns("fallback-french");
+        _urlSegmentProviders = new UrlSegmentProviderCollection(() => new[] { urlSegmentProvider.Object });
+        var builder = CreateBuilder();
+        var content = CreateContentMock(variation: ContentVariation.Culture);
+        content.Setup(c => c.AvailableCultures).Returns(new[] { "en-US", "fr-FR" });
+        content.Setup(c => c.IsCulturePublished(It.IsAny<string>())).Returns(true);
+        content.Setup(c => c.GetCultureName(It.IsAny<string>())).Returns("Name");
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.Multiple(() =>
+        {
+            Assert.That(GetSingleValue(result, "urlName_en-us"), Is.EqualTo("fallback-english"));
+            Assert.That(GetSingleValue(result, "urlName_fr-fr"), Is.EqualTo("fallback-french"));
+        });
+        _documentUrlService.Verify(x => x.GetUrlSegment(It.IsAny<Guid>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Never);
+    }
+
+    [Test]
+    public void GetValueSets_Populates_CreateDate_And_UpdateDate()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock();
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.Multiple(() =>
+        {
+            Assert.That(GetSingleValue(result, "createDate"), Is.EqualTo(new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc)));
+            Assert.That(GetSingleValue(result, "updateDate"), Is.EqualTo(new DateTime(2024, 6, 1, 0, 0, 0, DateTimeKind.Utc)));
+        });
+    }
+
+    [Test]
+    public void GetValueSets_Sets_NodeType_To_ContentType_Id()
+    {
+        var builder = CreateBuilder();
+        var content = CreateContentMock(contentTypeId: 555);
+        var result = builder.GetValueSets(content.Object).Single();
+        Assert.That(GetSingleValue(result, "nodeType"), Is.EqualTo("555"));
+    }
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Examine/UmbracoIndexUniqueKeyFieldNameTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Examine/UmbracoIndexUniqueKeyFieldNameTests.cs
new file mode 100644
index 000000000000..552764cfd8d6
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Examine/UmbracoIndexUniqueKeyFieldNameTests.cs
@@ -0,0 +1,64 @@
+using Examine;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Infrastructure.Examine;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.Examine;
+
+[TestFixture]
+public class UmbracoIndexUniqueKeyFieldNameTests
+{
+    [Test]
+    public void IUmbracoIndex_Default_UniqueKeyFieldName_Returns_NodeKeyFieldName()
+    {
+        // Stub that implements IUmbracoIndex without overriding UniqueKeyFieldName,
+        // so the default interface implementation is exercised.
+        IUmbracoIndex index = new StubUmbracoIndex();
+
+        Assert.AreEqual(UmbracoExamineFieldNames.NodeKeyFieldName, index.UniqueKeyFieldName);
+    }
+
+    [Test]
+    public void DeliveryApiContentIndex_ItemId_Constant_Matches_Expected_Value()
+    {
+        Assert.AreEqual("itemId", UmbracoExamineFieldNames.DeliveryApiContentIndex.ItemId);
+    }
+
+    /// <summary>
+    /// Minimal stub that implements <see cref="IUmbracoIndex"/> without overriding
+    /// <see cref="IUmbracoIndex.UniqueKeyFieldName"/>, so the default interface
+    /// implementation is tested.
+    /// </summary>
+    private class StubUmbracoIndex : IUmbracoIndex
+    {
+        public bool EnableDefaultEventHandler => false;
+
+        public bool PublishedValuesOnly => false;
+
+        public bool SupportProtectedContent => false;
+
+        public string Name => "Stub";
+
+        public ISearcher Searcher => Mock.Of<ISearcher>();
+
+        public ReadOnlyFieldDefinitionCollection FieldDefinitions => new(Array.Empty<FieldDefinition>());
+
+        public void IndexItems(IEnumerable<ValueSet> values) { }
+
+        public void DeleteFromIndex(IEnumerable<string> itemIds) { }
+
+        public void CreateIndex() { }
+
+        public bool IndexExists() => false;
+
+        public long GetDocumentCount() => 0;
+
+        public IEnumerable<string> GetFieldNames() => [];
+
+        public event EventHandler<IndexOperationEventArgs>? IndexOperationComplete;
+
+        public event EventHandler<IndexingItemEventArgs>? TransformingIndexValues;
+
+        public event EventHandler<IndexingErrorEventArgs>? IndexingError;
+    }
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/RecurringHostedServiceBaseTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/RecurringHostedServiceBaseTests.cs
index 394d763ed6d6..229f63b3ec56 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/RecurringHostedServiceBaseTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/HostedServices/RecurringHostedServiceBaseTests.cs
@@ -58,4 +58,59 @@ public void Logs_And_Returns_Notification_Delay_From_Default_When_Provided_Time_
                 It.IsAny<Func<It.IsAnyType, Exception, string>>()),
             Times.Once);
     }
+
+    [Test]
+    public void ComputeNextDelay_Subtracts_Elapsed_Time_From_Period()
+    {
+        var period = TimeSpan.FromSeconds(10);
+        var elapsed = TimeSpan.FromSeconds(3);
+
+        TimeSpan result = RecurringHostedServiceBase.ComputeNextDelay(period, elapsed);
+
+        Assert.AreEqual(TimeSpan.FromSeconds(7), result);
+    }
+
+    [Test]
+    public void ComputeNextDelay_Returns_Zero_When_Execution_Exceeds_Period()
+    {
+        var period = TimeSpan.FromSeconds(10);
+        var elapsed = TimeSpan.FromSeconds(15);
+
+        TimeSpan result = RecurringHostedServiceBase.ComputeNextDelay(period, elapsed);
+
+        Assert.AreEqual(TimeSpan.Zero, result);
+    }
+
+    [Test]
+    public void ComputeNextDelay_Returns_Full_Period_When_Elapsed_Is_Zero()
+    {
+        var period = TimeSpan.FromSeconds(10);
+        var elapsed = TimeSpan.Zero;
+
+        TimeSpan result = RecurringHostedServiceBase.ComputeNextDelay(period, elapsed);
+
+        Assert.AreEqual(period, result);
+    }
+
+    [Test]
+    public void ComputeNextDelay_Returns_Zero_When_Execution_Equals_Period()
+    {
+        var period = TimeSpan.FromSeconds(10);
+        var elapsed = TimeSpan.FromSeconds(10);
+
+        TimeSpan result = RecurringHostedServiceBase.ComputeNextDelay(period, elapsed);
+
+        Assert.AreEqual(TimeSpan.Zero, result);
+    }
+
+    [Test]
+    public void ComputeNextDelay_Returns_Zero_For_Negative_Period()
+    {
+        var period = TimeSpan.FromMilliseconds(-1);
+        var elapsed = TimeSpan.FromSeconds(1);
+
+        TimeSpan result = RecurringHostedServiceBase.ComputeNextDelay(period, elapsed);
+
+        Assert.AreEqual(TimeSpan.Zero, result);
+    }
 }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Media/SvgDimensionExtractorTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Media/SvgDimensionExtractorTests.cs
new file mode 100644
index 000000000000..aa70b3ffbe6f
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Media/SvgDimensionExtractorTests.cs
@@ -0,0 +1,274 @@
+using System.Drawing;
+using System.Text;
+using Microsoft.Extensions.Logging.Abstractions;
+using NUnit.Framework;
+using Umbraco.Cms.Infrastructure.Media;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.Media;
+
+public class SvgDimensionExtractorTests
+{
+    [Test]
+    public void Returns_Null_For_Non_Readable_Stream()
+    {
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes("<svg/>"));
+        stream.Close();
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.Null);
+    }
+
+    [Test]
+    public void Restores_Stream_Position_After_Reading()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" width="100" height="50">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        stream.Position = 10;
+        var sut = CreateSvgDimensionExtractor();
+
+        sut.GetDimensions(stream);
+
+        Assert.That(stream.Position, Is.EqualTo(10));
+    }
+
+    [Test]
+    public void Returns_Null_For_Invalid_Xml()
+    {
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes("this is not xml"));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.Null);
+    }
+
+    [Test]
+    public void Returns_Null_For_No_Dimensions_And_No_ViewBox()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.Null);
+    }
+
+    [Test]
+    public void Falls_Back_To_ViewBox_For_Decimal_Width_Height()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" width="100.5" height="50.3" viewBox="0 0 200 100">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.EqualTo(new Size(200, 100)));
+    }
+
+    [Test]
+    public void Can_Parse_Attribute_Width_Height_No_Unit()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" width="100" height="50" viewBox="0 0 301 152">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.EqualTo(new Size(100, 50)));
+    }
+
+    [Test]
+    public void Can_Parse_Attribute_Width_Height_Pixels()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" width="100px" height="50px" viewBox="0 0 301 152">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.EqualTo(new Size(100, 50)));
+    }
+
+    [Test]
+    public void Returns_Null_For_Zero_Width_Height()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" width="0" height="0">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.Null);
+    }
+
+    [Test]
+    public void Returns_Null_For_Negative_Width_Height()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" width="-10" height="-5">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.Null);
+    }
+
+    [Test]
+    public void Can_Parse_And_Fallback_Attribute_Width_Height_Percent()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" width="100%" height="50%" viewBox="0 0 301 152">
+                      <rect x="0" y="0" width="50" height="75" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.EqualTo(new Size(301, 152)));
+    }
+
+    [Test]
+    public void Can_Parse_And_Fallback_Width_Height_Em()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" width="10em" height="5em" viewBox="0 0 301 152">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.EqualTo(new Size(301, 152)));
+    }
+
+    [Test]
+    public void Can_Parse_From_ViewBox()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 301 152">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.EqualTo(new Size(301, 152)));
+    }
+
+    [Test]
+    public void Can_Parse_From_ViewBox_Single_Digits()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 8 4">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.EqualTo(new Size(8, 4)));
+    }
+
+    [Test]
+    public void Can_Parse_ViewBox_With_Fractional_Values()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 99.7 50.3">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.EqualTo(new Size(100, 50)));
+    }
+
+    [Test]
+    public void Can_Parse_ViewBox_With_Comma_Separators()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0,0,301,152">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.EqualTo(new Size(301, 152)));
+    }
+
+    [Test]
+    public void Returns_Null_For_Negative_ViewBox_Dimensions()
+    {
+        var svg = """
+                  <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 -100 -50">
+                      <rect x="0" y="0" width="300" height="150" />
+                  </svg>
+                  """;
+
+        using var stream = new MemoryStream(Encoding.UTF8.GetBytes(svg));
+        var sut = CreateSvgDimensionExtractor();
+
+        Size? result = sut.GetDimensions(stream);
+
+        Assert.That(result, Is.Null);
+    }
+
+    private SvgDimensionExtractor CreateSvgDimensionExtractor() => new(NullLogger<SvgDimensionExtractor>.Instance);
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/PropertyEditors/SvgFileUploadMediaSavingNotificationHandlerTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/PropertyEditors/SvgFileUploadMediaSavingNotificationHandlerTests.cs
new file mode 100644
index 000000000000..58663828c12e
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/PropertyEditors/SvgFileUploadMediaSavingNotificationHandlerTests.cs
@@ -0,0 +1,297 @@
+using System.Drawing;
+using System.Text;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Events;
+using Umbraco.Cms.Core.IO;
+using Umbraco.Cms.Core.Media;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Notifications;
+using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Core.Strings;
+using Umbraco.Cms.Infrastructure.PropertyEditors.NotificationHandlers;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Infrastructure.PropertyEditors;
+
+[TestFixture]
+public class SvgFileUploadMediaSavingNotificationHandlerTests
+{
+    private Mock<ISvgDimensionExtractor> _svgDimensionExtractor = null!;
+    private Mock<IFileSystem> _fileSystem = null!;
+    private SvgFileUploadMediaSavingNotificationHandler _handler = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _svgDimensionExtractor = new Mock<ISvgDimensionExtractor>();
+        _fileSystem = new Mock<IFileSystem>();
+
+        var mediaFileManager = new MediaFileManager(
+            _fileSystem.Object,
+            Mock.Of<IMediaPathScheme>(),
+            NullLogger<MediaFileManager>.Instance,
+            Mock.Of<IShortStringHelper>(),
+            Mock.Of<IServiceProvider>(),
+            new Lazy<ICoreScopeProvider>(() => Mock.Of<ICoreScopeProvider>()));
+
+        _handler = new SvgFileUploadMediaSavingNotificationHandler(
+            NullLogger<SvgFileUploadMediaSavingNotificationHandler>.Instance,
+            _svgDimensionExtractor.Object,
+            mediaFileManager);
+    }
+
+    [Test]
+    public void Skips_Non_Vector_Graphics_Media_Type()
+    {
+        IMedia media = CreateMedia(Constants.Conventions.MediaTypes.Image);
+
+        _handler.Handle(CreateNotification(media));
+
+        _svgDimensionExtractor.Verify(x => x.GetDimensions(It.IsAny<Stream>()), Times.Never);
+    }
+
+    [Test]
+    public void Skips_When_Width_Property_Missing()
+    {
+        IMedia media = CreateMedia(
+            Constants.Conventions.MediaTypes.VectorGraphicsAlias,
+            hasWidthProperty: false,
+            hasHeightProperty: true);
+
+        _handler.Handle(CreateNotification(media));
+
+        _svgDimensionExtractor.Verify(x => x.GetDimensions(It.IsAny<Stream>()), Times.Never);
+    }
+
+    [Test]
+    public void Skips_When_Height_Property_Missing()
+    {
+        IMedia media = CreateMedia(
+            Constants.Conventions.MediaTypes.VectorGraphicsAlias,
+            hasWidthProperty: true,
+            hasHeightProperty: false);
+
+        _handler.Handle(CreateNotification(media));
+
+        _svgDimensionExtractor.Verify(x => x.GetDimensions(It.IsAny<Stream>()), Times.Never);
+    }
+
+    [Test]
+    public void Skips_When_No_Upload_Field_Property()
+    {
+        IMedia media = CreateMedia(
+            Constants.Conventions.MediaTypes.VectorGraphicsAlias,
+            uploadFieldAlias: null);
+
+        _handler.Handle(CreateNotification(media));
+
+        _svgDimensionExtractor.Verify(x => x.GetDimensions(It.IsAny<Stream>()), Times.Never);
+    }
+
+    [Test]
+    public void Skips_When_Upload_Value_Is_Empty()
+    {
+        IMedia media = CreateMedia(
+            Constants.Conventions.MediaTypes.VectorGraphicsAlias,
+            uploadValue: string.Empty);
+
+        _handler.Handle(CreateNotification(media));
+
+        _svgDimensionExtractor.Verify(x => x.GetDimensions(It.IsAny<Stream>()), Times.Never);
+    }
+
+    [Test]
+    public void Skips_When_File_Does_Not_Exist()
+    {
+        IMedia media = CreateMedia(
+            Constants.Conventions.MediaTypes.VectorGraphicsAlias,
+            uploadValue: "/media/test.svg");
+
+        _fileSystem.Setup(x => x.GetRelativePath(It.IsAny<string>())).Returns("media/test.svg");
+        _fileSystem.Setup(x => x.FileExists("media/test.svg")).Returns(false);
+
+        _handler.Handle(CreateNotification(media));
+
+        _svgDimensionExtractor.Verify(x => x.GetDimensions(It.IsAny<Stream>()), Times.Never);
+    }
+
+    [Test]
+    public void Sets_Width_And_Height_When_Dimensions_Extracted()
+    {
+        IMedia media = CreateMedia(
+            Constants.Conventions.MediaTypes.VectorGraphicsAlias,
+            uploadValue: "/media/test.svg",
+            widthProperty: out var widthProperty,
+            heightProperty: out var heightProperty);
+
+        var svgStream = new MemoryStream(Encoding.UTF8.GetBytes("<svg/>"));
+
+        _fileSystem.Setup(x => x.GetRelativePath(It.IsAny<string>())).Returns("media/test.svg");
+        _fileSystem.Setup(x => x.FileExists("media/test.svg")).Returns(true);
+        _fileSystem.Setup(x => x.OpenFile("media/test.svg")).Returns(svgStream);
+        _svgDimensionExtractor.Setup(x => x.GetDimensions(svgStream)).Returns(new Size(200, 100));
+
+        _handler.Handle(CreateNotification(media));
+
+        widthProperty.Verify(x => x.SetValue(200, null, null), Times.Once);
+        heightProperty.Verify(x => x.SetValue(100, null, null), Times.Once);
+    }
+
+    [Test]
+    public void Does_Not_Set_Properties_When_Dimensions_Not_Extracted()
+    {
+        IMedia media = CreateMedia(
+            Constants.Conventions.MediaTypes.VectorGraphicsAlias,
+            uploadValue: "/media/test.svg",
+            widthProperty: out var widthProperty,
+            heightProperty: out var heightProperty);
+
+        var svgStream = new MemoryStream(Encoding.UTF8.GetBytes("<svg/>"));
+
+        _fileSystem.Setup(x => x.GetRelativePath(It.IsAny<string>())).Returns("media/test.svg");
+        _fileSystem.Setup(x => x.FileExists("media/test.svg")).Returns(true);
+        _fileSystem.Setup(x => x.OpenFile("media/test.svg")).Returns(svgStream);
+        _svgDimensionExtractor.Setup(x => x.GetDimensions(svgStream)).Returns((Size?)null);
+
+        _handler.Handle(CreateNotification(media));
+
+        widthProperty.Verify(x => x.SetValue(It.IsAny<object?>(), It.IsAny<string?>(), It.IsAny<string?>()), Times.Never);
+        heightProperty.Verify(x => x.SetValue(It.IsAny<object?>(), It.IsAny<string?>(), It.IsAny<string?>()), Times.Never);
+    }
+
+    [Test]
+    public void Passes_Culture_And_Segment_To_SetValue()
+    {
+        IMedia media = CreateMedia(
+            Constants.Conventions.MediaTypes.VectorGraphicsAlias,
+            uploadValue: "/media/test.svg",
+            culture: "en-US",
+            segment: "seg1",
+            widthProperty: out var widthProperty,
+            heightProperty: out var heightProperty);
+
+        var svgStream = new MemoryStream(Encoding.UTF8.GetBytes("<svg/>"));
+
+        _fileSystem.Setup(x => x.GetRelativePath(It.IsAny<string>())).Returns("media/test.svg");
+        _fileSystem.Setup(x => x.FileExists("media/test.svg")).Returns(true);
+        _fileSystem.Setup(x => x.OpenFile("media/test.svg")).Returns(svgStream);
+        _svgDimensionExtractor.Setup(x => x.GetDimensions(svgStream)).Returns(new Size(200, 100));
+
+        _handler.Handle(CreateNotification(media));
+
+        widthProperty.Verify(x => x.SetValue(200, "en-US", "seg1"), Times.Once);
+        heightProperty.Verify(x => x.SetValue(100, "en-US", "seg1"), Times.Once);
+    }
+
+    private static MediaSavingNotification CreateNotification(IMedia media)
+        => new(media, new EventMessages());
+
+    private static IMedia CreateMedia(
+        string contentTypeAlias,
+        bool hasWidthProperty = true,
+        bool hasHeightProperty = true,
+        string? uploadFieldAlias = Constants.PropertyEditors.Aliases.UploadField,
+        string? uploadValue = null,
+        string? culture = null,
+        string? segment = null) =>
+        CreateMedia(
+            contentTypeAlias,
+            hasWidthProperty,
+            hasHeightProperty,
+            uploadFieldAlias,
+            uploadValue,
+            culture,
+            segment,
+            out _,
+            out _);
+
+    private static IMedia CreateMedia(
+        string contentTypeAlias,
+        string? uploadValue,
+        out Mock<IProperty> widthProperty,
+        out Mock<IProperty> heightProperty,
+        string? culture = null,
+        string? segment = null) =>
+        CreateMedia(
+            contentTypeAlias,
+            hasWidthProperty: true,
+            hasHeightProperty: true,
+            uploadFieldAlias: Constants.PropertyEditors.Aliases.UploadField,
+            uploadValue: uploadValue,
+            culture: culture,
+            segment: segment,
+            widthProperty: out widthProperty,
+            heightProperty: out heightProperty);
+
+    private static IMedia CreateMedia(
+        string contentTypeAlias,
+        bool hasWidthProperty,
+        bool hasHeightProperty,
+        string? uploadFieldAlias,
+        string? uploadValue,
+        string? culture,
+        string? segment,
+        out Mock<IProperty> widthProperty,
+        out Mock<IProperty> heightProperty)
+    {
+        var contentType = new Mock<ISimpleContentType>();
+        contentType.Setup(x => x.Alias).Returns(contentTypeAlias);
+
+        var properties = new Mock<IPropertyCollection>();
+
+        // Width property.
+        widthProperty = new Mock<IProperty>();
+        IProperty? widthOut = widthProperty.Object;
+        properties
+            .Setup(x => x.TryGetValue(Constants.Conventions.Media.Width, out widthOut))
+            .Returns(hasWidthProperty);
+
+        // Height property.
+        heightProperty = new Mock<IProperty>();
+        IProperty? heightOut = heightProperty.Object;
+        properties
+            .Setup(x => x.TryGetValue(Constants.Conventions.Media.Height, out heightOut))
+            .Returns(hasHeightProperty);
+
+        // Upload field property.
+        if (uploadFieldAlias is not null)
+        {
+            var uploadPropertyType = new Mock<IPropertyType>();
+            uploadPropertyType.Setup(x => x.PropertyEditorAlias).Returns(uploadFieldAlias);
+
+            var uploadProperty = new Mock<IProperty>();
+            uploadProperty.Setup(x => x.PropertyType).Returns(uploadPropertyType.Object);
+            uploadProperty.Setup(x => x.GetValue(culture, segment)).Returns(uploadValue);
+            uploadProperty.Setup(x => x.Values).Returns(new List<IPropertyValue>
+            {
+                CreatePropertyValue(culture, segment),
+            });
+
+            properties
+                .Setup(x => x.GetEnumerator())
+                .Returns(() => new List<IProperty> { uploadProperty.Object }.GetEnumerator());
+        }
+        else
+        {
+            properties
+                .Setup(x => x.GetEnumerator())
+                .Returns(() => new List<IProperty>().GetEnumerator());
+        }
+
+        var media = new Mock<IMedia>();
+        media.Setup(x => x.ContentType).Returns(contentType.Object);
+        media.Setup(x => x.Properties).Returns(properties.Object);
+
+        return media.Object;
+    }
+
+    private static IPropertyValue CreatePropertyValue(string? culture, string? segment)
+    {
+        var propertyValue = new Mock<IPropertyValue>();
+        propertyValue.Setup(x => x.Culture).Returns(culture);
+        propertyValue.Setup(x => x.Segment).Returns(segment);
+        return propertyValue.Object;
+    }
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Security/MemberRoleStoreTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Security/MemberRoleStoreTests.cs
index d5f34f3a65bd..f43a03c6f3b3 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Security/MemberRoleStoreTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Infrastructure/Security/MemberRoleStoreTests.cs
@@ -1,6 +1,3 @@
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using Microsoft.AspNetCore.Identity;
 using Moq;
 using NUnit.Framework;
@@ -39,14 +36,14 @@ public MemberRoleStore CreateSut()
     }
 
     [Test]
-    public void GivenICreateAMemberRole_AndTheGroupIsNull_ThenIShouldGetAFailedIdentityResult()
+    public async Task GivenICreateAMemberRole_AndTheGroupIsNull_ThenIShouldGetAFailedIdentityResult()
     {
         // arrange
         var sut = CreateSut();
         var fakeCancellationToken = CancellationToken.None;
 
         // act
-        Action actual = () => sut.CreateAsync(null, fakeCancellationToken);
+        Func<Task> actual = async () => await sut.CreateAsync(null, fakeCancellationToken);
 
         // assert
         Assert.That(actual, Throws.ArgumentNullException);
@@ -64,7 +61,7 @@ public async Task GivenICreateAMemberRole_AndTheGroupIsPopulatedCorrectly_ThenIS
         var mockMemberGroup = Mock.Of<IMemberGroup>(m =>
             m.Name == "fakeGroupName" && m.CreatorId == 77);
 
-        _mockMemberGroupService.Setup(x => x.Save(mockMemberGroup));
+        _mockMemberGroupService.Setup(x => x.CreateAsync(mockMemberGroup));
 
         // act
         var identityResult = await sut.CreateAsync(fakeRole, fakeCancellationToken);
@@ -72,7 +69,7 @@ public async Task GivenICreateAMemberRole_AndTheGroupIsPopulatedCorrectly_ThenIS
         // assert
         Assert.IsTrue(identityResult.Succeeded);
         Assert.IsTrue(!identityResult.Errors.Any());
-        _mockMemberGroupService.Verify(x => x.Save(It.IsAny<MemberGroup>()));
+        _mockMemberGroupService.Verify(x => x.CreateAsync(It.IsAny<MemberGroup>()));
     }
 
     [Test]
@@ -88,7 +85,7 @@ public async Task
             m.Name == "fakeGroupName" && m.CreatorId == 777);
 
         _mockMemberGroupService.Setup(x => x.GetById(777)).Returns(mockMemberGroup);
-        _mockMemberGroupService.Setup(x => x.Save(mockMemberGroup));
+        _mockMemberGroupService.Setup(x => x.UpdateAsync(mockMemberGroup));
 
         // act
         var identityResult = await sut.UpdateAsync(fakeRole, fakeCancellationToken);
@@ -112,7 +109,7 @@ public async Task
             m.Name == "fakeGroupName" && m.CreatorId == 777);
 
         _mockMemberGroupService.Setup(x => x.GetById(777)).Returns(mockMemberGroup);
-        _mockMemberGroupService.Setup(x => x.Save(mockMemberGroup));
+        _mockMemberGroupService.Setup(x => x.UpdateAsync(mockMemberGroup));
 
         // act
         var identityResult = await sut.UpdateAsync(fakeRole, fakeCancellationToken);
@@ -120,7 +117,7 @@ public async Task
         // assert
         Assert.IsTrue(identityResult.Succeeded);
         Assert.IsTrue(!identityResult.Errors.Any());
-        _mockMemberGroupService.Verify(x => x.Save(It.IsAny<IMemberGroup>()));
+        _mockMemberGroupService.Verify(x => x.UpdateAsync(It.IsAny<IMemberGroup>()));
         _mockMemberGroupService.Verify(x => x.GetById(777));
     }
 
@@ -168,7 +165,7 @@ public void GivenIUpdateAMemberRole_AndTheRoleIsNull_ThenAnExceptionShouldBeThro
         var fakeCancellationToken = CancellationToken.None;
 
         // act
-        Action actual = () => sut.UpdateAsync(null, fakeCancellationToken);
+        Func<Task> actual = async () => await sut.UpdateAsync(null, fakeCancellationToken);
 
         // assert
         Assert.That(actual, Throws.ArgumentNullException);
@@ -272,7 +269,7 @@ public Task GivenIFindAMemberRoleByRoleId_AndIdCannotBeParsedToAnIntOrGuid_ThenI
         var fakeCancellationToken = CancellationToken.None;
 
         // act
-        Action actual = () => sut.FindByIdAsync(fakeRole.Id, fakeCancellationToken);
+        Func<Task> actual = async () => await sut.FindByIdAsync(fakeRole.Id, fakeCancellationToken);
 
         // assert
         Assert.That(actual, Throws.TypeOf<ArgumentOutOfRangeException>());
@@ -293,7 +290,7 @@ public async Task
         IMemberGroup fakeMemberGroup = _groupBuilder.WithName("fakeGroupName").WithCreatorId(123).WithId(777)
             .WithKey(fakeRoleGuid).Build();
 
-        _mockMemberGroupService.Setup(x => x.GetById(fakeRoleGuid)).Returns(fakeMemberGroup);
+        _mockMemberGroupService.Setup(x => x.GetAsync(fakeRoleGuid)).ReturnsAsync(fakeMemberGroup);
 
         // act
         IdentityRole actual = await sut.FindByIdAsync(fakeRoleGuid.ToString());
@@ -301,7 +298,7 @@ public async Task
         // assert
         Assert.AreEqual(fakeRole.Name, actual.Name);
         Assert.AreEqual(fakeRole.Id, actual.Id);
-        _mockMemberGroupService.Verify(x => x.GetById(fakeRoleGuid));
+        _mockMemberGroupService.Verify(x => x.GetAsync(fakeRoleGuid));
         _mockMemberGroupService.VerifyNoOtherCalls();
     }
 
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Web.Website/ApplicationUrlConfigurationNotificationHandlerTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Web.Website/ApplicationUrlConfigurationNotificationHandlerTests.cs
new file mode 100644
index 000000000000..9ffc473ed524
--- /dev/null
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Web.Website/ApplicationUrlConfigurationNotificationHandlerTests.cs
@@ -0,0 +1,110 @@
+// Copyright (c) Umbraco.
+// See LICENSE for more details.
+
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Moq;
+using NUnit.Framework;
+using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.Notifications;
+using Umbraco.Cms.Web.Common.AspNetCore;
+
+namespace Umbraco.Cms.Tests.UnitTests.Umbraco.Web.Website;
+
+[TestFixture]
+public class ApplicationUrlConfigurationNotificationHandlerTests
+{
+    private FakeLogger _logger = null!;
+
+    [SetUp]
+    public void SetUp() => _logger = new FakeLogger();
+
+    [Test]
+    public void Handle_WithExplicitUrl_LogsInformationWithConfiguredUrl()
+    {
+        var settings = new WebRoutingSettings { UmbracoApplicationUrl = "https://my-site.com" };
+        var sut = CreateHandler(settings);
+
+        sut.Handle(new UmbracoApplicationStartedNotification(false));
+
+        Assert.That(_logger.LogEntries, Has.Exactly(1).Matches<FakeLogger.LogEntry>(
+            e => e.Level == LogLevel.Information && e.Message.Contains("configured")));
+    }
+
+    [Test]
+    public void Handle_NoneMode_NoExplicitUrl_LogsWarning()
+    {
+        var settings = new WebRoutingSettings { ApplicationUrlDetection = ApplicationUrlDetection.None };
+        var sut = CreateHandler(settings);
+
+        sut.Handle(new UmbracoApplicationStartedNotification(false));
+
+        Assert.That(_logger.LogEntries, Has.Exactly(1).Matches<FakeLogger.LogEntry>(
+            e => e.Level == LogLevel.Warning && e.Message.Contains("auto-detection is disabled")));
+    }
+
+    [Test]
+    public void Handle_FirstRequestMode_NoExplicitUrl_LogsAutoDetectionEnabled()
+    {
+        var settings = new WebRoutingSettings { ApplicationUrlDetection = ApplicationUrlDetection.FirstRequest };
+        var sut = CreateHandler(settings);
+
+        sut.Handle(new UmbracoApplicationStartedNotification(false));
+
+        Assert.That(_logger.LogEntries, Has.Exactly(1).Matches<FakeLogger.LogEntry>(
+            e => e.Level == LogLevel.Information && e.Message.Contains("auto-detection is enabled")));
+    }
+
+    [Test]
+    public void Handle_EveryRequestMode_NoExplicitUrl_LogsAutoDetectionEnabled()
+    {
+        var settings = new WebRoutingSettings { ApplicationUrlDetection = ApplicationUrlDetection.EveryRequest };
+        var sut = CreateHandler(settings);
+
+        sut.Handle(new UmbracoApplicationStartedNotification(false));
+
+        Assert.That(_logger.LogEntries, Has.Exactly(1).Matches<FakeLogger.LogEntry>(
+            e => e.Level == LogLevel.Information && e.Message.Contains("auto-detection is enabled")));
+    }
+
+    [Test]
+    public void Handle_WithExplicitUrl_DoesNotLogWarning()
+    {
+        var settings = new WebRoutingSettings
+        {
+            UmbracoApplicationUrl = "https://my-site.com",
+            ApplicationUrlDetection = ApplicationUrlDetection.None,
+        };
+        var sut = CreateHandler(settings);
+
+        sut.Handle(new UmbracoApplicationStartedNotification(false));
+
+        Assert.That(_logger.LogEntries, Has.None.Matches<FakeLogger.LogEntry>(
+            e => e.Level == LogLevel.Warning));
+    }
+
+    private ApplicationUrlConfigurationNotificationHandler CreateHandler(WebRoutingSettings settings)
+    {
+        var optionsMonitor = Mock.Of<IOptionsMonitor<WebRoutingSettings>>(
+            m => m.CurrentValue == settings);
+        return new ApplicationUrlConfigurationNotificationHandler(_logger, optionsMonitor);
+    }
+
+    /// <summary>
+    ///     Simple logger that captures log entries for assertion, avoiding Moq proxy issues
+    ///     with <c>ILogger&lt;T&gt;</c> of internal types.
+    /// </summary>
+    private sealed class FakeLogger : ILogger<ApplicationUrlConfigurationNotificationHandler>
+    {
+        public List<LogEntry> LogEntries { get; } = [];
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+            => LogEntries.Add(new LogEntry(logLevel, formatter(state, exception)));
+
+        public bool IsEnabled(LogLevel logLevel) => true;
+
+        public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null;
+
+        public record LogEntry(LogLevel Level, string Message);
+    }
+}
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Web.Website/AspNetCoreHostingEnvironmentTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Web.Website/AspNetCoreHostingEnvironmentTests.cs
index 5fac76d42487..745d2f2ff3a9 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Web.Website/AspNetCoreHostingEnvironmentTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Web.Website/AspNetCoreHostingEnvironmentTests.cs
@@ -1,7 +1,11 @@
 // Copyright (c) Umbraco.
 // See LICENSE for more details.
 
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Options;
+using Moq;
 using NUnit.Framework;
+using Umbraco.Cms.Core.Configuration.Models;
 using Umbraco.Cms.Core.Strings;
 using Umbraco.Cms.Tests.UnitTests.AutoFixture;
 using Umbraco.Cms.Web.Common.AspNetCore;
@@ -36,12 +40,224 @@ public void EnsurePathIsApplicationRootPrefixed()
         Assert.AreEqual("~/Views/Template.cshtml", PathUtility.EnsurePathIsApplicationRootPrefixed("~/Views/Template.cshtml"));
     }
 
-    [AutoMoqData]
     [Test]
-    public void EnsureApplicationMainUrl(AspNetCoreHostingEnvironment sut)
+    public void EnsureApplicationMainUrl()
     {
+        var sut = CreateWithDefaultConfig(ApplicationUrlDetection.FirstRequest);
         var url = new Uri("http://localhost:5000");
         sut.EnsureApplicationMainUrl(url);
         Assert.AreEqual(sut.ApplicationMainUrl, url);
     }
+
+    /// <summary>
+    /// Creates an AspNetCoreHostingEnvironment with UmbracoApplicationUrl = null,
+    /// simulating the default configuration where no explicit URL is configured.
+    /// </summary>
+    private static AspNetCoreHostingEnvironment CreateWithDefaultConfig(
+        ApplicationUrlDetection detection = ApplicationUrlDetection.FirstRequest)
+    {
+        var hostingSettings = new HostingSettings();
+        var webRoutingSettings = new WebRoutingSettings
+        {
+            ApplicationUrlDetection = detection,
+        };
+
+        var hostingSettingsMonitor = Mock.Of<IOptionsMonitor<HostingSettings>>(
+            m => m.CurrentValue == hostingSettings);
+        var webRoutingSettingsMonitor = Mock.Of<IOptionsMonitor<WebRoutingSettings>>(
+            m => m.CurrentValue == webRoutingSettings);
+
+        var webHostEnvironment = new Mock<IWebHostEnvironment>();
+        webHostEnvironment.Setup(e => e.ContentRootPath).Returns(Path.GetTempPath());
+        webHostEnvironment.Setup(e => e.WebRootPath).Returns(Path.GetTempPath());
+        webHostEnvironment.Setup(e => e.ApplicationName).Returns("TestApp");
+
+        return new AspNetCoreHostingEnvironment(
+            hostingSettingsMonitor,
+            webRoutingSettingsMonitor,
+            webHostEnvironment.Object);
+    }
+
+    [Test]
+    public void EnsureApplicationMainUrl_LocksAfterFirstUrl()
+    {
+        var sut = CreateWithDefaultConfig(ApplicationUrlDetection.FirstRequest);
+
+        var legitimateUrl = new Uri("https://legit-site.com");
+        var attackerUrl = new Uri("https://non-configured-site.com");
+
+        // Step 1: Normal traffic sets the URL
+        sut.EnsureApplicationMainUrl(legitimateUrl);
+        Assert.AreEqual(legitimateUrl, sut.ApplicationMainUrl, "Initial legitimate URL should be set");
+
+        // Step 2: Attacker sends request with forged Host header — must be ignored
+        sut.EnsureApplicationMainUrl(attackerUrl);
+        Assert.AreEqual(legitimateUrl, sut.ApplicationMainUrl, "Attacker URL must not overwrite the legitimate URL");
+
+        // Step 3: Legitimate traffic continues — URL remains stable
+        sut.EnsureApplicationMainUrl(legitimateUrl);
+        Assert.AreEqual(legitimateUrl, sut.ApplicationMainUrl, "Legitimate URL is retained");
+    }
+
+    [Test]
+    public void EnsureApplicationMainUrl_IgnoresSubsequentUrls()
+    {
+        var sut = CreateWithDefaultConfig(ApplicationUrlDetection.FirstRequest);
+
+        var legitimateUrl = new Uri("https://legit-site.com");
+
+        sut.EnsureApplicationMainUrl(legitimateUrl);
+        sut.EnsureApplicationMainUrl(new Uri("https://evil1.com"));
+        sut.EnsureApplicationMainUrl(new Uri("https://evil2.com"));
+
+        Assert.AreEqual(legitimateUrl, sut.ApplicationMainUrl, "First URL is locked, all subsequent URLs are ignored");
+    }
+
+    [Test]
+    public void EnsureApplicationMainUrl_NullDoesNotLock()
+    {
+        var sut = CreateWithDefaultConfig(ApplicationUrlDetection.FirstRequest);
+
+        sut.EnsureApplicationMainUrl(null);
+
+        var url = new Uri("https://legit-site.com");
+        sut.EnsureApplicationMainUrl(url);
+        Assert.AreEqual(url, sut.ApplicationMainUrl);
+    }
+
+    [Test]
+    public void EnsureApplicationMainUrl_NoneMode_NeverSetsUrl()
+    {
+        var sut = CreateWithDefaultConfig(ApplicationUrlDetection.None);
+
+        sut.EnsureApplicationMainUrl(new Uri("https://legit-site.com"));
+
+        Assert.IsNull(sut.ApplicationMainUrl);
+    }
+
+    [Test]
+    public void EnsureApplicationMainUrl_NoneMode_ExplicitConfigStillWorks()
+    {
+        var webRoutingSettings = new WebRoutingSettings
+        {
+            UmbracoApplicationUrl = "https://configured-site.com",
+            ApplicationUrlDetection = ApplicationUrlDetection.None,
+        };
+
+        var hostingSettingsMonitor = Mock.Of<IOptionsMonitor<HostingSettings>>(
+            m => m.CurrentValue == new HostingSettings());
+        var webRoutingSettingsMonitor = Mock.Of<IOptionsMonitor<WebRoutingSettings>>(
+            m => m.CurrentValue == webRoutingSettings);
+
+        var webHostEnvironment = new Mock<IWebHostEnvironment>();
+        webHostEnvironment.Setup(e => e.ContentRootPath).Returns(Path.GetTempPath());
+        webHostEnvironment.Setup(e => e.WebRootPath).Returns(Path.GetTempPath());
+        webHostEnvironment.Setup(e => e.ApplicationName).Returns("TestApp");
+
+        var sut = new AspNetCoreHostingEnvironment(
+            hostingSettingsMonitor,
+            webRoutingSettingsMonitor,
+            webHostEnvironment.Object);
+
+        // Explicit config is set in the constructor, not via auto-detection
+        Assert.AreEqual(new Uri("https://configured-site.com"), sut.ApplicationMainUrl);
+    }
+
+    [Test]
+    public void EnsureApplicationMainUrl_EveryRequest_OverwritesOnNewUrl()
+    {
+        var sut = CreateWithDefaultConfig(ApplicationUrlDetection.EveryRequest);
+
+        var url1 = new Uri("https://site-a.com");
+        var url2 = new Uri("https://site-b.com");
+
+        sut.EnsureApplicationMainUrl(url1);
+        Assert.AreEqual(url1, sut.ApplicationMainUrl);
+
+        sut.EnsureApplicationMainUrl(url2);
+        Assert.AreEqual(url2, sut.ApplicationMainUrl, "New URL should overwrite in EveryRequest mode");
+    }
+
+    [Test]
+    public void EnsureApplicationMainUrl_EveryRequest_SameUrlNoOp()
+    {
+        var sut = CreateWithDefaultConfig(ApplicationUrlDetection.EveryRequest);
+
+        var url = new Uri("https://site-a.com");
+        sut.EnsureApplicationMainUrl(url);
+        sut.EnsureApplicationMainUrl(url);
+
+        Assert.AreEqual(url, sut.ApplicationMainUrl, "Repeated same URL is a no-op");
+    }
+
+    [Test]
+    public void EnsureApplicationMainUrl_EveryRequest_ExplicitConfigTakesPrecedence()
+    {
+        var webRoutingSettings = new WebRoutingSettings
+        {
+            UmbracoApplicationUrl = "https://configured-site.com",
+            ApplicationUrlDetection = ApplicationUrlDetection.EveryRequest,
+        };
+
+        var hostingSettingsMonitor = Mock.Of<IOptionsMonitor<HostingSettings>>(
+            m => m.CurrentValue == new HostingSettings());
+        var webRoutingSettingsMonitor = Mock.Of<IOptionsMonitor<WebRoutingSettings>>(
+            m => m.CurrentValue == webRoutingSettings);
+
+        var webHostEnvironment = new Mock<IWebHostEnvironment>();
+        webHostEnvironment.Setup(e => e.ContentRootPath).Returns(Path.GetTempPath());
+        webHostEnvironment.Setup(e => e.WebRootPath).Returns(Path.GetTempPath());
+        webHostEnvironment.Setup(e => e.ApplicationName).Returns("TestApp");
+
+        var sut = new AspNetCoreHostingEnvironment(
+            hostingSettingsMonitor,
+            webRoutingSettingsMonitor,
+            webHostEnvironment.Object);
+
+        Assert.AreEqual(new Uri("https://configured-site.com"), sut.ApplicationMainUrl);
+
+        // Attempt to overwrite via auto-detection
+        sut.EnsureApplicationMainUrl(new Uri("https://non-configured-site.com"));
+
+        Assert.AreEqual(
+            new Uri("https://configured-site.com"),
+            sut.ApplicationMainUrl,
+            "Explicit config prevents auto-detection overwrite");
+    }
+
+    [Test]
+    public void EnsureApplicationMainUrl_WithExplicitConfig_IgnoresHostHeader()
+    {
+        // When UmbracoApplicationUrl IS configured, poisoning should be impossible
+        var webRoutingSettings = new WebRoutingSettings
+        {
+            UmbracoApplicationUrl = "https://configured-site.com",
+        };
+
+        var hostingSettingsMonitor = Mock.Of<IOptionsMonitor<HostingSettings>>(
+            m => m.CurrentValue == new HostingSettings());
+        var webRoutingSettingsMonitor = Mock.Of<IOptionsMonitor<WebRoutingSettings>>(
+            m => m.CurrentValue == webRoutingSettings);
+
+        var webHostEnvironment = new Mock<IWebHostEnvironment>();
+        webHostEnvironment.Setup(e => e.ContentRootPath).Returns(Path.GetTempPath());
+        webHostEnvironment.Setup(e => e.WebRootPath).Returns(Path.GetTempPath());
+        webHostEnvironment.Setup(e => e.ApplicationName).Returns("TestApp");
+
+        var sut = new AspNetCoreHostingEnvironment(
+            hostingSettingsMonitor,
+            webRoutingSettingsMonitor,
+            webHostEnvironment.Object);
+
+        Assert.AreEqual(new Uri("https://configured-site.com"), sut.ApplicationMainUrl);
+
+        // Attempt override.
+        sut.EnsureApplicationMainUrl(new Uri("https://non-configured-site.com"));
+
+        // Should remain configured value.
+        Assert.AreEqual(
+            new Uri("https://configured-site.com"),
+            sut.ApplicationMainUrl,
+            "Explicit config prevents host header poisoning");
+    }
 }