Changed locator (#15714 )

update backoffice submodule
V14: Migrate nucache to use System.Text.Json (#15685 )
2024-02-14 14:08:42 +01:00 · 2024-02-14 13:10:06 +01:00 · 2024-02-14 12:10:45 +01:00 · 2024-02-13 15:08:42 +01:00 · 2024-02-13 13:28:28 +01:00 · 2024-02-13 12:18:09 +01:00
2282 changed files with 122021 additions and 34602 deletions
@@ -1,3 +1,4 @@
 **/*
 !tests/Umbraco.Tests.Integration/bin/**
 !tests/Umbraco.Tests.UnitTests/bin/**
+**/node_modules
@@ -5,14 +5,34 @@

 This solution folder contains the projects for the new backoffice. If you're looking to fix or improve the existing CMS, this is not the place to do it, although we do very much appreciate your efforts.

+### Getting Started: Management API
+
+This branch contains the project for the new Management API as well as the new Backoffice. To get started with the Management API you should:
+* Run any of the executables (Umbraco.Web.UI or Umbraco.Web.UI.New)
+* Access "/umbraco/swagger" in the browser to see the Swagger interface
+* The API lives in the Umbraco.Cms.Api.Management project
+
+### Getting Started: Backoffice
+To run the new Backoffice:
+* Execute `git submodule init` and then `git submodule update` to get the files into Umbraco.Web.UI.New.Client project
+* Run Umbraco.Web.UI.New project
+    * If you get a white page delete Umbraco.Cms.StaticAssets\wwwroot\umbraco folder and run `npm ci && npm run build:for:cms` inside Umbraco.Web.UI.New.Client folder to clear out any leftover files from older versions. 
+* If you are going to work on the Backoffice, you can either go to the Umbraco.Web.UI.New.Client folder and check out a new branch or set it up in your IDE, which will allow you to commit to each repository simultaneously:
+  * **Rider**: Preferences -> Version Control -> Directory Mappings -> Click the '+' sign
+
+### Latest version
+* If you want to get the latest changes from the Backoffice repository, run `git submodule update` again which will pull the latest main branch.
+
 ### Project structure

 Since the new backoffice API is still very much a work in progress, we've created new projects for the new backoffice API:

 * Umbrao.Cms.ManagementApi - The "presentation layer" for the management API
 * "New" versions of existing projects, should be merged with the existing projects when the new API is released:
-    * Umbraco.New.Cms.Core
-    * Umbraco.New.Cms.Infrastructure
-    * Umbraco.New.Cms.Web.Common
+    * Umbraco.Cms.Core
+    * Umbraco.Cms.Infrastructure
+    * Umbraco.Cms.Web.Common
+    * Umbraco.Web.UI.New
+    * Umbraco.Web.UI.New.Client

 This also means that we have to use "InternalsVisibleTo" for the new projects since these should be able to access the internal classes since they will when they get merged.
@@ -23,6 +23,7 @@ env:
  DOTNET_GENERATE_ASPNET_CERTIFICATE: false
  DOTNET_SKIP_FIRST_TIME_EXPERIENCE: true
  DOTNET_CLI_TELEMETRY_OPTOUT: true
+  NODE_OPTIONS: --max_old_space_size=16384

 jobs:
  CodeQL-Build:
@@ -37,6 +38,7 @@ jobs:
      uses: actions/checkout@v3
      with:
        fetch-depth: 0
+        submodules: true

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
@@ -50,10 +50,6 @@ tools/docfx/
 # Ignore rule for clearing out Belle (avoid rebuilding all the time)
 preserve.belle

-# Ignore rule for output of generated documentation files from grunt docserve
-/src/Umbraco.Web.UI.Docs/api/
-/src/Umbraco.Web.UI.Docs/package-lock.json
-
 # csharp-docs
 /build/csharp-docs/api/
 /build/csharp-docs/_site/
@@ -68,7 +64,13 @@ preserve.belle
 /build/docs.zip
 /build/ui-docs.zip
 /build/csharp-docs.zip
-/src/Umbraco.Cms.StaticAssets/wwwroot/umbraco/
+/src/Umbraco.Cms.StaticAssets/wwwroot/umbraco/auth
+/src/Umbraco.Cms.StaticAssets/wwwroot/umbraco/backoffice
+/src/Umbraco.Cms.StaticAssets/wwwroot/umbraco/assets
+/src/Umbraco.Cms.StaticAssets/wwwroot/umbraco/js
+/src/Umbraco.Cms.StaticAssets/wwwroot/umbraco/lib
+/src/Umbraco.Cms.StaticAssets/wwwroot/umbraco/views
+/src/Umbraco.Cms.StaticAssets/wwwroot/umbraco/login

 # Environment specific data
 /src/Umbraco.Web.UI.Client/[Bb]uild/
@@ -91,6 +93,7 @@ preserve.belle

 # Tests
 /tests/Umbraco.Tests.AcceptanceTest/.env
+/tests/Umbraco.Tests.AcceptanceTest/playwright/.auth
 /tests/Umbraco.Tests.Integration.SqlCe/DatabaseContextTests.sdf
 /tests/Umbraco.Tests.Integration.SqlCe/[Uu]mbraco/[Dd]ata/TEMP/
 /tests/Umbraco.Tests.Integration/appsettings.Tests.Local.json
@@ -103,10 +106,13 @@ preserve.belle
 # Ignore auto-generated schema
 /src/Umbraco.Cms.Targets/tasks/
 /src/Umbraco.Cms.Targets/appsettings-schema.*.json
+/src/Umbraco.Cms.Targets/umbraco-package-schema.json
 /src/Umbraco.Web.UI/appsettings-schema.json
 /src/Umbraco.Web.UI/appsettings-schema.*.json
+/src/Umbraco.Web.UI/umbraco-package-schema.json
 /tests/Umbraco.Tests.Integration/appsettings-schema.json
 /tests/Umbraco.Tests.Integration/appsettings-schema.*.json
+/tests/Umbraco.Tests.Integration/umbraco-package-schema.json
 /src/Umbraco.Cms/appsettings-schema.json
 playwright-report
 trace.zip
@@ -0,0 +1,3 @@
+[submodule "src/Umbraco.Web.UI.New.Client"]
+	path = src/Umbraco.Web.UI.New.Client
+	url = https://github.com/umbraco/Umbraco.CMS.Backoffice.git
@@ -28,9 +28,9 @@

  <!-- Package Validation -->
  <PropertyGroup>
-    <GenerateCompatibilitySuppressionFile>false</GenerateCompatibilitySuppressionFile>
-    <EnablePackageValidation>true</EnablePackageValidation>
-    <PackageValidationBaselineVersion>13.0.0</PackageValidationBaselineVersion>
+    <GenerateCompatibilitySuppressionFile>true</GenerateCompatibilitySuppressionFile>
+    <EnablePackageValidation>false</EnablePackageValidation>
+    <PackageValidationBaselineVersion>14.0.0</PackageValidationBaselineVersion>
    <EnableStrictModeForCompatibleFrameworksInPackage>true</EnableStrictModeForCompatibleFrameworksInPackage>
    <EnableStrictModeForCompatibleTfms>true</EnableStrictModeForCompatibleTfms>
  </PropertyGroup>
@@ -19,6 +19,7 @@
    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="8.0.1" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore.SqlServer" Version="8.0.1" />
    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.1" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="8.0.0" />
    <PackageVersion Include="Microsoft.Extensions.Configuration.Abstractions" Version="8.0.0" />
    <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="8.0.0" />
    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
@@ -32,7 +33,6 @@
    <PackageVersion Include="Microsoft.Extensions.Options" Version="8.0.1" />
    <PackageVersion Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />
    <PackageVersion Include="Microsoft.Extensions.Options.DataAnnotations" Version="8.0.0" />
-    <PackageVersion Include="System.Runtime.Caching" Version="8.0.0" />
  </ItemGroup>
  <!-- Umbraco packages -->
  <ItemGroup>
@@ -41,12 +41,13 @@
  </ItemGroup>
  <!-- Third-party packages -->
  <ItemGroup>
-    <PackageVersion Include="Asp.Versioning.Mvc" Version="7.1.1" />
-    <PackageVersion Include="Asp.Versioning.Mvc.ApiExplorer" Version="7.1.0" />
+    <PackageVersion Include="Asp.Versioning.Mvc" Version="8.0.0" />
+    <PackageVersion Include="Asp.Versioning.Mvc.ApiExplorer" Version="8.0.0" />
    <PackageVersion Include="Dazinator.Extensions.FileProviders" Version="2.0.0" />
    <PackageVersion Include="Examine" Version="3.2.0" />
    <PackageVersion Include="Examine.Core" Version="3.2.0" />
    <PackageVersion Include="HtmlAgilityPack" Version="1.11.57" />
+    <PackageVersion Include="JsonPatch.Net" Version="2.1.0" />
    <PackageVersion Include="K4os.Compression.LZ4" Version="1.3.6" />
    <PackageVersion Include="MailKit" Version="4.3.0" />
    <PackageVersion Include="Markdown" Version="2.2.1" />
@@ -89,4 +90,4 @@
    <!-- Both Dazinator.Extensions.FileProviders and MiniProfiler.AspNetCore.Mvc bring in a vulnerable version of System.Text.RegularExpressions -->
    <PackageVersion Include="System.Text.RegularExpressions" Version="4.3.1" />
  </ItemGroup>
-</Project>
+</Project>
@@ -17,6 +17,10 @@ parameters:
    displayName: Deploy to NuGet
    type: boolean
    default: false
+  - name: npmDeploy
+    displayName: Deploy to Npm
+    type: boolean
+    default: false
  - name: buildApiDocs
    displayName: Build API docs
    type: boolean
@@ -67,12 +71,15 @@ stages:
  - stage: Build
    variables:
      npm_config_cache: $(Pipeline.Workspace)/.npm_client
+      NODE_OPTIONS: --max_old_space_size=16384
    jobs:
      - job: A
        displayName: Build Umbraco CMS
        pool:
          vmImage: 'ubuntu-latest'
        steps:
+          - checkout: self
+            submodules: true
          - task: NodeTool@0
            displayName: Use Node.js $(nodeVersion)
            retryCountOnTaskFailure: 3
@@ -95,20 +102,21 @@ stages:
              gulpFile: src/Umbraco.Web.UI.Client/gulpfile.js
              targets: coreBuild
              workingDirectory: src/Umbraco.Web.UI.Client
-          - task: npm@1
+          - script: npm ci --no-fund --no-audit --prefer-offline
            displayName: Run npm ci (Login)
-            inputs:
-              command: custom
-              workingDir: src/Umbraco.Web.UI.Login
-              verbose: false
-              customCommand: ci
-          - task: npm@1
+            workingDirectory: src/Umbraco.Web.UI.Login
+          - script: npm run build
            displayName: Run npm build (Login)
-            inputs:
-              command: custom
-              workingDir: src/Umbraco.Web.UI.Login
-              verbose: false
-              customCommand: run build
+            workingDirectory: src/Umbraco.Web.UI.Login
+          - script: npm ci --no-fund --no-audit --prefer-offline
+            displayName: Run npm ci (Bellissima)
+            workingDirectory: src/Umbraco.Web.UI.New.Client
+          - script: npm run build:for:cms
+            displayName: Run build (Bellissima)
+            workingDirectory: src/Umbraco.Web.UI.New.Client
+          - script: npm run build
+            displayName: Run Login Build (Bellissima)
+            workingDirectory: src/Umbraco.Web.UI.New.Client/apps/auth
          - task: UseDotNet@2
            displayName: Use .NET SDK from global.json
            inputs:
@@ -135,6 +143,24 @@ stages:
            inputs:
              targetPath: $(Build.SourcesDirectory)
              artifactName: build_output
+          - bash: |
+              echo "##[command]Running npm version"
+              echo "##[debug]Version: $PACKAGE_VERSION"
+              echo "##[command]Running npm pack"
+              echo "##[debug]Output directory: $(Build.ArtifactStagingDirectory)"
+              npm version $PACKAGE_VERSION --allow-same-version --no-git-tag-version
+              mkdir $(Build.ArtifactStagingDirectory)/npm
+              npm pack --pack-destination $(Build.ArtifactStagingDirectory)/npm
+              mv .npmrc $(Build.ArtifactStagingDirectory)/npm/
+            displayName: Prepare Bellissima npm package
+            env:
+              PACKAGE_VERSION: $(build.NBGV_NpmPackageVersion)
+            workingDirectory: src/Umbraco.Web.UI.New.Client
+          - task: PublishPipelineArtifact@1
+            displayName: Publish Bellissima npm artifact
+            inputs:
+              targetPath: $(Build.ArtifactStagingDirectory)/npm
+              artifactName: npm

  - stage: Build_Docs
    condition: and(succeeded(), or(eq(dependencies.Build.outputs['A.build.NBGV_PublicRelease'], 'True'), ${{parameters.buildApiDocs}}))
@@ -150,10 +176,9 @@ stages:
          vmImage: 'windows-latest'
        steps:
          - task: UseDotNet@2
-            displayName: Use .NET $(dotnetVersion)
+            displayName: Use .NET SDK from global.json
            inputs:
-              version: $(dotnetVersion)
-              includePreviewVersions: $(dotnetIncludePreviewVersions)
+              useGlobalJson: true
          - task: PowerShell@2
            displayName: Install DocFX
            inputs:
@@ -198,29 +223,41 @@ stages:
        displayName: Build js API Reference
        pool:
          vmImage: 'ubuntu-latest'
+        variables:
+          npm_config_cache: $(Pipeline.Workspace)/.npm_client
+          NODE_OPTIONS: --max_old_space_size=16384
+          BASE_PATH: /v$(umbracoMajorVersion)/ui
        steps:
+          - checkout: self
+            submodules: true
          - task: NodeTool@0
-            displayName: Use Node.js 10.15.x
+            displayName: Use Node.js $(nodeVersion)
            retryCountOnTaskFailure: 3
            inputs:
-              versionSpec: 10.15.x # Won't work with higher versions
-          - script: |
-              npm ci --no-fund --no-audit --prefer-offline
-              npx gulp docs
-
-              major="$(umbracoMajorVersion)"
-              echo "major version: $major"
-
-              baseUrl="https://apidocs.umbraco.com/v$major/ui/"
-              echo "baseUrl: $baseUrl"
-
-              sed -i "s|baseUrl = .*|baseUrl = '$baseUrl',|" api/index.html
-            displayName: Generate js Docs
-            workingDirectory:  $(Build.SourcesDirectory)/src/Umbraco.Web.UI.Docs
+              versionSpec: $(nodeVersion)
+          - task: Cache@2
+            displayName: Cache node_modules
+            inputs:
+              key: '"npm_client" | "$(Agent.OS)"| $(Build.SourcesDirectory)/src/Umbraco.Web.UI.Client/package-lock.json | $(Build.SourcesDirectory)/src/Umbraco.Web.UI.New.Client/package-lock.json'
+              restoreKeys: |
+                "npm_client" | "$(Agent.OS)"
+                "npm_client"
+              path: $(npm_config_cache)
+          - script: npm ci --no-fund --no-audit --prefer-offline
+            workingDirectory:  src/Umbraco.Web.UI.New.Client
+            displayName: Run npm ci
+          - script: npm run storybook:build
+            displayName: Build Storybook
+            env:
+              VITE_BASE_PATH: $(BASE_PATH)/
+            workingDirectory: $(Build.SourcesDirectory)/src/Umbraco.Web.UI.New.Client
+          - script: sed -i "s|/umbraco/backoffice|$(BASE_PATH)/umbraco/backoffice|" assets/*.js
+            displayName: Replace BASE_PATH on assets
+            workingDirectory: $(Build.SourcesDirectory)/src/Umbraco.Web.UI.New.Client/storybook-static
          - task: ArchiveFiles@2
            displayName: Archive js Docs
            inputs:
-              rootFolderOrFile: $(Build.SourcesDirectory)/src/Umbraco.Web.UI.Docs/api
+              rootFolderOrFile: $(Build.SourcesDirectory)/src/Umbraco.Web.UI.New.Client/storybook-static
              includeRootFolder: false
              archiveFile: $(Build.ArtifactStagingDirectory)/ui-docs.zip
          - task: PublishPipelineArtifact@1
@@ -319,7 +356,7 @@ stages:

      # Integration Tests (SQL Server)
      - job:
-        timeoutInMinutes: 120
+        timeoutInMinutes: 180
        condition: or(eq(stageDependencies.Build.A.outputs['build.NBGV_PublicRelease'], 'True'), ${{parameters.sqlServerIntegrationTests}})
        displayName: Integration Tests (SQL Server)
        strategy:
@@ -692,7 +729,7 @@ stages:
    dependsOn:
      - Unit
      - Integration
-      # - E2E # TODO: Enable when stable.
+      # - E2E
    condition: and(succeeded(), or(eq(dependencies.Build.outputs['A.build.NBGV_PublicRelease'], 'True'), ${{parameters.myGetDeploy}}))
    jobs:
      - job:
@@ -714,6 +751,41 @@ stages:
                publishFeedCredentials: 'MyGet - Umbraco Nightly'
              ${{ else }}:
                publishFeedCredentials: 'MyGet - Pre-releases'
+      - job:
+        displayName: Push to pre-release feed (npm)
+        steps:
+          - checkout: none
+          - download: current
+            artifact: npm
+          - 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
+            displayName: Add scoped registry to .npmrc
+          - task: npmAuthenticate@0
+            displayName: Authenticate with npm (MyGet)
+            inputs:
+              workingFile: '$(Pipeline.Workspace)/npm/.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 --access public "${files[0]}"
+            displayName: Push to npm (MyGet)
+            workingDirectory: $(Pipeline.Workspace)/npm
+
  - stage: Deploy_NuGet
    displayName: NuGet release
    dependsOn:
@@ -738,15 +810,45 @@ stages:
              nuGetFeedType: 'external'
              publishFeedCredentials: 'NuGet - Umbraco.*'

+  - stage: Deploy_Npm
+    displayName: Npm release
+    condition: and(succeeded(), or(eq(dependencies.Build.outputs['A.build.NBGV_PublicRelease'], 'True'), ${{parameters.npmDeploy}}))
+    dependsOn:
+      - Deploy_NuGet
+    jobs:
+      - job: Publish
+        displayName: Push to NPM
+        steps:
+          - checkout: none
+          - download: current
+            artifact: npm
+          - bash: echo "@umbraco-cms:registry=https://registry.npmjs.org" >> .npmrc
+            workingDirectory: $(Pipeline.Workspace)/npm
+            displayName: Add scoped registry to .npmrc
+          - task: npmAuthenticate@0
+            displayName: Authenticate with npm
+            inputs:
+              workingFile: $(Pipeline.Workspace)/npm/.npmrc
+              customEndpoint: 'NPM - Umbraco Backoffice'
+          - script: |
+              # 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 --tag $npmTag --access public "${files[0]}"
+            displayName: Push to npm
+            workingDirectory: $(Pipeline.Workspace)/npm
+
  - stage: Upload_API_Docs
    pool:
      vmImage: 'windows-latest' # Apparently AzureFileCopy is windows only :(
    variables:
      umbracoMajorVersion: $[ stageDependencies.Build.A.outputs['build.NBGV_VersionMajor'] ]
-    displayName: Upload API Documention
+    displayName: Upload API Documentation
    dependsOn:
      - Build
-      - Deploy_NuGet
+      - Deploy_MyGet # Change to "Deploy_Nuget" after release of v14
    condition: and(succeeded(), or(eq(dependencies.Build.outputs['A.build.NBGV_PublicRelease'], 'True'), ${{parameters.uploadApiDocs}}))
    jobs:
      - job:
@@ -771,6 +873,7 @@ stages:
              storage: umbracoapidocs
              ContainerName: '$web'
              BlobPrefix: v$(umbracoMajorVersion)/csharp
+              CleanTargetBeforeCopy: true
      - job:
        displayName: Upload js Docs
        steps:
@@ -793,3 +896,4 @@ stages:
              storage: umbracoapidocs
              ContainerName: '$web'
              BlobPrefix: v$(umbracoMajorVersion)/ui
+              CleanTargetBeforeCopy: true
@@ -0,0 +1,22 @@
+namespace Umbraco.Cms.Api.Common.Attributes;
+
+public abstract class ShortGenericSchemaNameAttribute : Attribute
+{
+    public Type[] GenericTypes { get; set; }
+
+    public string SchemaName { get; set; }
+
+    public ShortGenericSchemaNameAttribute(string schemaName, Type[] genericTypes)
+    {
+        GenericTypes = genericTypes;
+        SchemaName = schemaName;
+    }
+}
+
+public class ShortGenericSchemaNameAttribute<T1, T2> : ShortGenericSchemaNameAttribute
+{
+    public ShortGenericSchemaNameAttribute(string schemaName)
+        : base(schemaName, new[] { typeof(T1), typeof(T2) })
+    {
+    }
+}
@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Umbraco.Extensions;

 namespace Umbraco.Cms.Api.Common.Builders;

@@ -8,6 +9,8 @@ public class ProblemDetailsBuilder
    private string? _title;
    private string? _detail;
    private string? _type;
+    private string? _operationStatus;
+    private IDictionary<string, object>? _extensions;

    public ProblemDetailsBuilder WithTitle(string title)
    {
@@ -27,11 +30,45 @@ public class ProblemDetailsBuilder
        return this;
    }

-    public ProblemDetails Build() =>
-        new()
+    public ProblemDetailsBuilder WithOperationStatus<TEnum>(TEnum operationStatus)
+        where TEnum : Enum
+    {
+        _operationStatus = operationStatus.ToString();
+        return this;
+    }
+
+    public ProblemDetailsBuilder WithRequestModelErrors(IDictionary<string, string[]> errors)
+        => WithExtension(nameof(HttpValidationProblemDetails.Errors).ToFirstLowerInvariant(), errors);
+
+    public ProblemDetailsBuilder WithExtension(string key, object value)
+    {
+        _extensions ??= new Dictionary<string, object>();
+        _extensions[key] = value;
+        return this;
+    }
+
+    public ProblemDetails Build()
+    {
+        var problemDetails = new ProblemDetails
        {
            Title = _title,
            Detail = _detail,
            Type = _type ?? "Error",
        };
+
+        if (_operationStatus is not null)
+        {
+            problemDetails.Extensions["operationStatus"] = _operationStatus;
+        }
+
+        if (_extensions is not null)
+        {
+            foreach (KeyValuePair<string, object> extension in _extensions)
+            {
+                problemDetails.Extensions[extension.Key] = extension.Value;
+            }
+        }
+
+        return problemDetails;
+    }
 }
@@ -1,23 +1,22 @@
-using System.Security.Cryptography;
 using Microsoft.Extensions.DependencyInjection;
+using System.Security.Cryptography;
 using Microsoft.IdentityModel.Tokens;
 using Umbraco.Cms.Api.Common.Security;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.DependencyInjection;
+using Umbraco.Cms.Infrastructure.BackgroundJobs.Jobs;
 using Umbraco.Cms.Infrastructure.HostedServices;
+using Umbraco.Extensions;

 namespace Umbraco.Cms.Api.Common.DependencyInjection;

 public static class UmbracoBuilderAuthExtensions
 {
-    private static bool _initialized;
-
    public static IUmbracoBuilder AddUmbracoOpenIddict(this IUmbracoBuilder builder)
    {
-        if (_initialized is false)
+        if (builder.Services.Any(x=>x.ImplementationType == typeof(OpenIddictCleanupJob)) is false)
        {
            ConfigureOpenIddict(builder);
-            _initialized = true;
        }

        return builder;
@@ -34,13 +33,17 @@ public static class UmbracoBuilderAuthExtensions
                // FIXME: swap paths here so member API is first (see comment above)
                options
                    .SetAuthorizationEndpointUris(
-                        Paths.MemberApi.AuthorizationEndpoint.TrimStart(Constants.CharArrays.ForwardSlash))
+                        Paths.MemberApi.AuthorizationEndpoint.TrimStart(Constants.CharArrays.ForwardSlash),
+                        Paths.BackOfficeApi.AuthorizationEndpoint.TrimStart(Constants.CharArrays.ForwardSlash))
                    .SetTokenEndpointUris(
-                        Paths.MemberApi.TokenEndpoint.TrimStart(Constants.CharArrays.ForwardSlash))
+                        Paths.MemberApi.TokenEndpoint.TrimStart(Constants.CharArrays.ForwardSlash),
+                        Paths.BackOfficeApi.TokenEndpoint.TrimStart(Constants.CharArrays.ForwardSlash))
                    .SetLogoutEndpointUris(
-                        Paths.MemberApi.LogoutEndpoint.TrimStart(Constants.CharArrays.ForwardSlash))
+                        Paths.MemberApi.LogoutEndpoint.TrimStart(Constants.CharArrays.ForwardSlash),
+                        Paths.BackOfficeApi.LogoutEndpoint.TrimStart(Constants.CharArrays.ForwardSlash))
                    .SetRevocationEndpointUris(
-                        Paths.MemberApi.RevokeEndpoint.TrimStart(Constants.CharArrays.ForwardSlash));
+                        Paths.MemberApi.RevokeEndpoint.TrimStart(Constants.CharArrays.ForwardSlash),
+                        Paths.BackOfficeApi.RevokeEndpoint.TrimStart(Constants.CharArrays.ForwardSlash));

                // Enable authorization code flow with PKCE
                options
@@ -101,6 +104,6 @@ public static class UmbracoBuilderAuthExtensions
                options.UseDataProtection();
            });

-        builder.Services.AddHostedService<OpenIddictCleanup>();
+        builder.Services.AddRecurringBackgroundJob<OpenIddictCleanupJob>();
    }
 }
@@ -0,0 +1,50 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Routing;
+using Microsoft.Extensions.DependencyInjection;
+using Umbraco.Cms.Core;
+
+namespace Umbraco.Cms.Api.Common.Mvc.ActionResults;
+
+/// <summary>
+/// A "created at" action result with no response body.
+/// </summary>
+public sealed class EmptyCreatedAtActionResult : ActionResult
+{
+    private readonly string _actionName;
+    private readonly string _controllerName;
+    private readonly object _routeValues;
+    private readonly string _resourceIdentifier;
+
+    public EmptyCreatedAtActionResult(string actionName, string controllerName, object routeValues, string resourceIdentifier)
+    {
+        _actionName = actionName;
+        _controllerName = controllerName;
+        _routeValues = routeValues;
+        _resourceIdentifier = resourceIdentifier;
+    }
+
+    public override void ExecuteResult(ActionContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+
+        HttpRequest request = context.HttpContext.Request;
+        IUrlHelper urlHelper = context.HttpContext.RequestServices.GetRequiredService<IUrlHelperFactory>().GetUrlHelper(context);
+
+        var url = urlHelper.Action(
+            _actionName,
+            _controllerName,
+            _routeValues,
+            request.Scheme,
+            request.Host.ToUriComponent());
+
+        if (string.IsNullOrEmpty(url))
+        {
+            throw new InvalidOperationException("No routes could be found that matched the provided route components");
+        }
+
+        context.HttpContext.Response.StatusCode = StatusCodes.Status201Created;
+        context.HttpContext.Response.Headers.Location = url;
+        context.HttpContext.Response.Headers[Constants.Headers.GeneratedResource] = _resourceIdentifier;
+    }
+}
@@ -1,4 +1,5 @@
 using System.Text.RegularExpressions;
+using Umbraco.Cms.Api.Common.Attributes;
 using Umbraco.Extensions;

 namespace Umbraco.Cms.Api.Common.OpenApi;
@@ -10,18 +11,9 @@ public class SchemaIdSelector : ISchemaIdSelector

    protected string UmbracoSchemaId(Type type)
    {
-        string SanitizedTypeName(Type t) => t.Name
-            // first grab the "non generic" part of any generic type name (i.e. "PagedViewModel`1" becomes "PagedViewModel")
-            .Split('`').First()
-            // then remove the "ViewModel" postfix from type names
-            .TrimEnd("ViewModel");
-
        var name = SanitizedTypeName(type);
-        if (type.IsGenericType)
-        {
-            // append the generic type names, ultimately turning i.e. "PagedViewModel<RelationItemViewModel>" into "PagedRelationItem"
-            name = $"{name}{string.Join(string.Empty, type.GenericTypeArguments.Select(SanitizedTypeName))}";
-        }
+
+        name = HandleGenerics(name, type);

        if (name.EndsWith("Model") == false)
        {
@@ -33,4 +25,58 @@ public class SchemaIdSelector : ISchemaIdSelector
        // make absolutely sure we don't pass any invalid named by removing all non-word chars
        return Regex.Replace(name, @"[^\w]", string.Empty);
    }
+
+    private string SanitizedTypeName(Type t) => t.Name
+        // first grab the "non generic" part of any generic type name (i.e. "PagedViewModel`1" becomes "PagedViewModel")
+        .Split('`').First()
+        // then remove the "ViewModel" postfix from type names
+        .TrimEnd("ViewModel");
+
+    private string HandleGenerics(string name, Type type)
+    {
+        if (!type.IsGenericType)
+        {
+            return name;
+        }
+
+        // find all types that implement this type and have an matching attribute
+        var assignableTypesWithAttributeInfo = AppDomain.CurrentDomain.GetAssemblies()
+            .Where(assembly => assembly.FullName?.StartsWith("Umbraco") == true)
+            .SelectMany(assembly => assembly.GetTypes())
+            .Where(t => t.IsAssignableTo(type))
+            .Select(t =>
+            {
+                var attribute = System.Attribute.GetCustomAttributes(t)
+                        .FirstOrDefault(attribute => attribute is ShortGenericSchemaNameAttribute) as
+                    ShortGenericSchemaNameAttribute;
+                return attribute == null
+                    ? new ShortSchemaNameAttributeInfo(t)
+                    : new ShortSchemaNameAttributeInfo(t, attribute.GenericTypes, attribute.SchemaName);
+            })
+            .Where(info => info.GenericTypes != null);
+
+        var matchingType = assignableTypesWithAttributeInfo
+            .SingleOrDefault(t => t.GenericTypes!.Length == type.GenericTypeArguments.Length
+                                  && t.GenericTypes.Intersect(type.GenericTypeArguments).Count() ==
+                                  type.GenericTypeArguments.Length && t.SchemaName.IsNullOrWhiteSpace() == false);
+
+        // use attribute custom name or append the generic type names, ultimately turning i.e. "PagedViewModel<RelationItemViewModel>" into "PagedRelationItem"
+        return matchingType != null
+            ? matchingType.SchemaName!
+            : $"{name}{string.Join(string.Empty, type.GenericTypeArguments.Select(SanitizedTypeName))}";
+    }
+
+    private class ShortSchemaNameAttributeInfo
+    {
+        public Type Type { get; set; }
+        public Type[]? GenericTypes { get; set; }
+        public string? SchemaName { get; set; }
+
+        public ShortSchemaNameAttributeInfo(Type type, Type[]? genericTypes = null, string? schemaName = null)
+        {
+            Type = type;
+            GenericTypes = genericTypes;
+            SchemaName = schemaName;
+        }
+    }
 }
@@ -62,6 +62,7 @@ public class SwaggerRouteTemplatePipelineFilter : UmbracoPipelineFilter
            swaggerUiOptions.SwaggerEndpoint($"{name}/swagger.json", $"{apiInfo.Title}");
        }

+        swaggerUiOptions.OAuthClientId(Constants.OAuthClientIds.Swagger);
        swaggerUiOptions.OAuthUsePkce();
    }

@@ -1,7 +1,22 @@
-namespace Umbraco.Cms.Api.Common.Security;
+namespace Umbraco.Cms.Api.Common.Security;

 public static class Paths
 {
+    public static class BackOfficeApi
+    {
+        public const string EndpointTemplate = "security/back-office";
+
+        public static readonly string AuthorizationEndpoint = EndpointPath($"{EndpointTemplate}/authorize");
+
+        public static readonly string TokenEndpoint = EndpointPath($"{EndpointTemplate}/token");
+
+        public static readonly string LogoutEndpoint = EndpointPath($"{EndpointTemplate}/signout");
+
+        public static readonly string RevokeEndpoint = EndpointPath($"{EndpointTemplate}/revoke");
+
+        private static string EndpointPath(string relativePath) => $"/umbraco/management/api/v1/{relativePath}";
+    }
+
    public static class MemberApi
    {
        public const string EndpointTemplate = "security/member";
@@ -22,7 +22,7 @@ public sealed class UmbracoJsonTypeInfoResolver : DefaultJsonTypeInfoResolver, I
            return cachedResult;
        }

-        var result = _typeFinder.FindClassesOfType(type).ToHashSet();
+        var result = _typeFinder.FindClassesOfType(type).OrderBy(x => x.Name).ToHashSet();
        _subTypesCache.TryAdd(type, result);
        return result;
    }
@@ -9,6 +9,8 @@
  </ItemGroup>

  <ItemGroup>
+    <PackageReference Include="Asp.Versioning.Mvc "/>
+    <PackageReference Include="Asp.Versioning.Mvc.ApiExplorer" />
    <PackageReference Include="Swashbuckle.AspNetCore" />
    <PackageReference Include="OpenIddict.Abstractions" />
    <PackageReference Include="OpenIddict.AspNetCore" />
@@ -17,5 +19,6 @@
  <ItemGroup>
    <ProjectReference Include="..\Umbraco.Core\Umbraco.Core.csproj" />
    <ProjectReference Include="..\Umbraco.Web.Common\Umbraco.Web.Common.csproj" />
+
  </ItemGroup>
 </Project>
@@ -1,35 +1,18 @@
 using Microsoft.AspNetCore.Mvc;
-using Microsoft.Extensions.DependencyInjection;
 using Umbraco.Cms.Core.DeliveryApi;
-using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Models.PublishedContent;
 using Umbraco.Cms.Core.Security;
-using Umbraco.Cms.Core.Services;

 namespace Umbraco.Cms.Api.Delivery.Controllers.Content;

 public abstract class ContentApiItemControllerBase : ContentApiControllerBase
 {
-    // TODO: Remove this in V14 when the obsolete constructors have been removed
-    private readonly IPublicAccessService _publicAccessService;
-
-    [Obsolete($"Please use the constructor that does not accept {nameof(IPublicAccessService)}. Will be removed in V14.")]
-    protected ContentApiItemControllerBase(
-        IApiPublishedContentCache apiPublishedContentCache,
-        IApiContentResponseBuilder apiContentResponseBuilder,
-        IPublicAccessService publicAccessService)
-        : this(apiPublishedContentCache, apiContentResponseBuilder)
-    {
-    }
-
    protected ContentApiItemControllerBase(
        IApiPublishedContentCache apiPublishedContentCache,
        IApiContentResponseBuilder apiContentResponseBuilder)
        : base(apiPublishedContentCache, apiContentResponseBuilder)
-        => _publicAccessService = StaticServiceProvider.Instance.GetRequiredService<IPublicAccessService>();
-
-    [Obsolete($"Please use {nameof(IPublicAccessService)} to test for content protection. Will be removed in V14.")]
-    protected bool IsProtected(IPublishedContent content) => _publicAccessService.IsProtected(content.Path);
+    {
+    }

    protected async Task<IActionResult?> HandleMemberAccessAsync(IPublishedContent contentItem, IRequestMemberAccessService requestMemberAccessService)
    {
@@ -1,16 +1,20 @@
-using System.Net;
 using Microsoft.AspNetCore.Mvc;
+using System.Net;
+using Microsoft.AspNetCore.Authorization;
 using Umbraco.Cms.Api.Common.Attributes;
 using Umbraco.Cms.Api.Common.Filters;
 using Umbraco.Cms.Api.Delivery.Configuration;
 using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Features;
+using Umbraco.Cms.Web.Common.Authorization;

 namespace Umbraco.Cms.Api.Delivery.Controllers;

 [ApiController]
 [JsonOptionsName(Constants.JsonOptionsNames.DeliveryApi)]
 [MapToApi(DeliveryApiConfiguration.ApiName)]
-public abstract class DeliveryApiControllerBase : Controller
+[Authorize(Policy = "New" + AuthorizationPolicies.UmbracoFeatureEnabled)]
+public abstract class DeliveryApiControllerBase : Controller, IUmbracoFeature
 {
    protected string DecodePath(string path)
    {
@@ -1,4 +1,4 @@
-using System.Security.Claims;
+using System.Security.Claims;
 using Asp.Versioning;
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Authentication;
@@ -1,4 +1,4 @@
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Umbraco.Cms.Core;
@@ -1,4 +1,4 @@
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using OpenIddict.Abstractions;
 using Umbraco.Cms.Core.Configuration.Models;
@@ -73,7 +73,7 @@ internal sealed class RevokeMemberAuthenticationTokensNotificationHandler
            return;
        }

-        _logger.LogInformation("Deleting {count} active tokens for member with ID {id}", tokens.Length, member.Id);
+        _logger.LogInformation("Revoking {count} active tokens for member with ID {id}", tokens.Length, member.Id);
        foreach (var token in tokens)
        {
            await _tokenManager.DeleteAsync(token);
@@ -1,4 +1,4 @@
-using OpenIddict.Abstractions;
+using OpenIddict.Abstractions;
 using Umbraco.Cms.Core;
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Infrastructure.Security;
@@ -1,4 +1,4 @@
-using System.Security.Claims;
+using System.Security.Claims;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Extensions.Options;
@@ -0,0 +1,61 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Microsoft.OpenApi.Models;
+using Swashbuckle.AspNetCore.SwaggerGen;
+using Umbraco.Cms.Api.Common.Serialization;
+using Umbraco.Cms.Api.Management.DependencyInjection;
+using Umbraco.Cms.Api.Management.OpenApi;
+
+namespace Umbraco.Cms.Api.Management.Configuration;
+
+public class ConfigureUmbracoManagementApiSwaggerGenOptions : IConfigureOptions<SwaggerGenOptions>
+{
+    private IUmbracoJsonTypeInfoResolver _umbracoJsonTypeInfoResolver;
+
+    public ConfigureUmbracoManagementApiSwaggerGenOptions(IUmbracoJsonTypeInfoResolver umbracoJsonTypeInfoResolver)
+    {
+        _umbracoJsonTypeInfoResolver = umbracoJsonTypeInfoResolver;
+    }
+
+    public void Configure(SwaggerGenOptions swaggerGenOptions)
+    {
+
+        swaggerGenOptions.SwaggerDoc(
+            ManagementApiConfiguration.ApiName,
+            new OpenApiInfo
+            {
+                Title = ManagementApiConfiguration.ApiTitle,
+                Version = "Latest",
+                Description = "This shows all APIs available in this version of Umbraco - including all the legacy apis that are available for backward compatibility",
+            });
+
+        swaggerGenOptions.OperationFilter<ResponseHeaderOperationFilter>();
+        swaggerGenOptions.SelectSubTypesUsing(_umbracoJsonTypeInfoResolver.FindSubTypes);
+        swaggerGenOptions.UseOneOfForPolymorphism();
+        swaggerGenOptions.UseAllOfForInheritance();
+
+        swaggerGenOptions.AddSecurityDefinition(
+            ManagementApiConfiguration.ApiSecurityName,
+            new OpenApiSecurityScheme
+             {
+                 In = ParameterLocation.Header,
+                 Name = "Umbraco",
+                 Type = SecuritySchemeType.OAuth2,
+                 Description = "Umbraco Authentication",
+                 Flows = new OpenApiOAuthFlows
+                 {
+                     AuthorizationCode = new OpenApiOAuthFlow
+                     {
+                         AuthorizationUrl =
+                             new Uri(Common.Security.Paths.BackOfficeApi.AuthorizationEndpoint, UriKind.Relative),
+                         TokenUrl = new Uri(Common.Security.Paths.BackOfficeApi.TokenEndpoint, UriKind.Relative)
+                     }
+                 }
+             });
+
+        // Sets Security requirement on backoffice apis
+        swaggerGenOptions.OperationFilter<BackOfficeSecurityRequirementsOperationFilter>();
+        swaggerGenOptions.SchemaFilter<RequireNonNullablePropertiesSchemaFilter>();
+    }
+
+}
@@ -0,0 +1,11 @@
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Routing;
+
+namespace Umbraco.Cms.Api.Management.Controllers.AuditLog;
+
+[ApiController]
+[VersionedApiBackOfficeRoute("audit-log")]
+[ApiExplorerSettings(GroupName = "Audit Log")]
+public class AuditLogControllerBase : ManagementApiControllerBase
+{
+}
@@ -0,0 +1,43 @@
+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.AuditLogs;
+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.AuditLog;
+
+[ApiVersion("1.0")]
+[Authorize(Policy = "New" + AuthorizationPolicies.SectionAccessContentOrMedia)]
+public class ByKeyAuditLogController : AuditLogControllerBase
+{
+    private readonly IAuditService _auditService;
+    private readonly IAuditLogPresentationFactory _auditLogPresentationFactory;
+
+    public ByKeyAuditLogController(IAuditService auditService, IAuditLogPresentationFactory auditLogPresentationFactory)
+    {
+        _auditService = auditService;
+        _auditLogPresentationFactory = auditLogPresentationFactory;
+    }
+
+    [HttpGet("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<AuditLogResponseModel>), StatusCodes.Status200OK)]
+    public async Task<IActionResult> ByKey(Guid id, Direction orderDirection = Direction.Descending, DateTime? sinceDate = null, int skip = 0, int take = 100)
+    {
+        PagedModel<IAuditItem> result = await _auditService.GetItemsByKeyAsync(id, skip, take, orderDirection, sinceDate);
+        IEnumerable<AuditLogResponseModel> mapped = _auditLogPresentationFactory.CreateAuditLogViewModel(result.Items);
+        var viewModel = new PagedViewModel<AuditLogResponseModel>
+        {
+            Total = result.Total,
+            Items = mapped,
+        };
+
+        return Ok(viewModel);
+    }
+}
@@ -0,0 +1,39 @@
+using Asp.Versioning;
+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.AuditLogs;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.AuditLog;
+
+[ApiVersion("1.0")]
+public class ByTypeAuditLogController : AuditLogControllerBase
+{
+    private readonly IAuditService _auditService;
+    private readonly IAuditLogPresentationFactory _auditLogPresentationFactory;
+
+    public ByTypeAuditLogController(IAuditService auditService, IAuditLogPresentationFactory auditLogPresentationFactory)
+    {
+        _auditService = auditService;
+        _auditLogPresentationFactory = auditLogPresentationFactory;
+    }
+
+    [HttpGet("type/{logType}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<AuditLogResponseModel>), StatusCodes.Status200OK)]
+    public async Task<IActionResult> ByType(AuditType logType, DateTime? sinceDate = null, int skip = 0, int take = 100)
+    {
+        IAuditItem[] result = _auditService.GetLogs(logType, sinceDate).ToArray();
+        IEnumerable<AuditLogResponseModel> mapped = _auditLogPresentationFactory.CreateAuditLogViewModel(result.Skip(skip).Take(take));
+        var viewModel = new PagedViewModel<AuditLogResponseModel>
+        {
+            Total = result.Length,
+            Items = mapped,
+        };
+
+        return await Task.FromResult(Ok(viewModel));
+    }
+}
@@ -0,0 +1,65 @@
+using Asp.Versioning;
+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.AuditLogs;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Exceptions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Membership;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.AuditLog;
+
+[ApiVersion("1.0")]
+public class CurrentUserAuditLogController : AuditLogControllerBase
+{
+    private readonly IAuditService _auditService;
+    private readonly IAuditLogPresentationFactory _auditLogPresentationFactory;
+    private readonly IUserService _userService;
+
+    public CurrentUserAuditLogController(
+        IAuditService auditService,
+        IAuditLogPresentationFactory auditLogPresentationFactory,
+        IUserService userService)
+    {
+        _auditService = auditService;
+        _auditLogPresentationFactory = auditLogPresentationFactory;
+        _userService = userService;
+    }
+
+    [HttpGet]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<AuditLogWithUsernameResponseModel>), StatusCodes.Status200OK)]
+    public async Task<IActionResult> CurrentUser(Direction orderDirection = Direction.Descending, DateTime? sinceDate = null, int skip = 0, int take = 100)
+    {
+        // FIXME: Pull out current backoffice user when its implemented.
+        // var userId = _backOfficeSecurityAccessor.BackOfficeSecurity?.GetUserId().Result ?? -1;
+        var userId = Constants.Security.SuperUserId;
+
+        IUser? user = _userService.GetUserById(userId);
+
+        if (user is null)
+        {
+            throw new PanicException("Could not find current user");
+        }
+
+        PagedModel<IAuditItem> result = await _auditService.GetPagedItemsByUserAsync(
+            user.Key,
+            skip,
+            take,
+            orderDirection,
+            null,
+            sinceDate);
+
+        IEnumerable<AuditLogWithUsernameResponseModel> mapped = _auditLogPresentationFactory.CreateAuditLogWithUsernameViewModels(result.Items);
+        var viewModel = new PagedViewModel<AuditLogWithUsernameResponseModel>
+        {
+            Total = result.Total,
+            Items = mapped,
+        };
+
+        return Ok(viewModel);
+    }
+}
@@ -0,0 +1,54 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Core.Configuration.Models;
+using Umbraco.Cms.Core.Hosting;
+
+namespace Umbraco.Cms.Api.Management;
+
+[BindProperties]
+public class
+    BackOfficeLoginModel
+{
+    /// <summary>
+    /// Gets or sets the value of the "ReturnUrl" query parameter or defaults to the configured Umbraco directory.
+    /// </summary>
+    [FromQuery(Name = "ReturnUrl")]
+    public string? ReturnUrl { get; set; }
+
+    /// <summary>
+    /// The configured Umbraco directory.
+    /// </summary>
+    public string? UmbracoUrl { get; set; }
+}
+
+[ApiExplorerSettings(IgnoreApi=true)]
+[Route("/umbraco/login")]
+public class BackOfficeLoginController : Controller
+{
+    private readonly IHostingEnvironment _hostingEnvironment;
+    private readonly GlobalSettings _globalSettings;
+
+    public BackOfficeLoginController(
+        IOptionsSnapshot<GlobalSettings> globalSettings,
+        IHostingEnvironment hostingEnvironment)
+    {
+        _hostingEnvironment = hostingEnvironment;
+        _globalSettings = globalSettings.Value ?? throw new ArgumentNullException(nameof(globalSettings));
+    }
+
+    // GET
+    public IActionResult Index(BackOfficeLoginModel model)
+    {
+        if (string.IsNullOrEmpty(model.UmbracoUrl))
+        {
+            model.UmbracoUrl = _hostingEnvironment.ToAbsolute(_globalSettings.UmbracoPath);
+        }
+
+        if (string.IsNullOrEmpty(model.ReturnUrl))
+        {
+            model.ReturnUrl = model.UmbracoUrl;
+        }
+
+        return View("/umbraco/UmbracoLogin/Index.cshtml", model);
+    }
+}
@@ -0,0 +1,114 @@
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Content;
+using Umbraco.Cms.Core.Models.ContentEditing;
+using Umbraco.Cms.Core.Models.ContentEditing.Validation;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Content;
+
+public class ContentControllerBase : ManagementApiControllerBase
+{
+    protected IActionResult ContentEditingOperationStatusResult(ContentEditingOperationStatus status)
+        => OperationStatusResult(status, problemDetailsBuilder => status switch
+        {
+            ContentEditingOperationStatus.CancelledByNotification => BadRequest(problemDetailsBuilder
+                .WithTitle("Cancelled by notification")
+                .WithDetail("A notification handler prevented the content operation.")
+                .Build()),
+            ContentEditingOperationStatus.ContentTypeNotFound => NotFound(problemDetailsBuilder
+                .WithTitle("The requested content could not be found")
+                .Build()),
+            ContentEditingOperationStatus.ContentTypeCultureVarianceMismatch => BadRequest(problemDetailsBuilder
+                .WithTitle("Content type culture variance mismatch")
+                .WithDetail("The content type variance did not match that of the passed content data.")
+                .Build()),
+            ContentEditingOperationStatus.NotFound => NotFound(problemDetailsBuilder
+                .WithTitle("The content could not be found")
+                .Build()),
+            ContentEditingOperationStatus.ParentNotFound => NotFound(problemDetailsBuilder
+                .WithTitle("The targeted content parent could not be found")
+                .Build()),
+            ContentEditingOperationStatus.ParentInvalid => BadRequest(problemDetailsBuilder
+                .WithTitle("Invalid parent")
+                .WithDetail("The targeted parent was not valid for the operation.")
+                .Build()),
+            ContentEditingOperationStatus.NotAllowed => BadRequest(problemDetailsBuilder
+                .WithTitle("Operation not permitted")
+                .WithDetail(
+                    "The attempted operation was not permitted, likely due to a permission/configuration mismatch with the operation.")
+                .Build()),
+            ContentEditingOperationStatus.TemplateNotFound => NotFound(problemDetailsBuilder
+                .WithTitle("The template could not be found")
+                .Build()),
+            ContentEditingOperationStatus.TemplateNotAllowed => BadRequest(problemDetailsBuilder
+                .WithTitle("Template not allowed")
+                .WithDetail("The selected template was not allowed for the operation.")
+                .Build()),
+            ContentEditingOperationStatus.PropertyTypeNotFound => NotFound(problemDetailsBuilder
+                .WithTitle("One or more property types could not be found")
+                .Build()),
+            ContentEditingOperationStatus.InTrash => BadRequest(problemDetailsBuilder
+                .WithTitle("Content is in the recycle bin")
+                .WithDetail("Could not perform the operation because the targeted content was in the recycle bin.")
+                .Build()),
+            ContentEditingOperationStatus.NotInTrash => BadRequest(problemDetailsBuilder
+                .WithTitle("Content is not in the recycle bin")
+                .WithDetail("The attempted operation requires the targeted content to be in the recycle bin.")
+                .Build()),
+            ContentEditingOperationStatus.SortingInvalid => BadRequest(problemDetailsBuilder
+                .WithTitle("Invalid sorting options")
+                .WithDetail("The supplied sorting operations were invalid. Additional details can be found in the log.")
+                .Build()),
+            ContentEditingOperationStatus.Unknown => StatusCode(
+                StatusCodes.Status500InternalServerError,
+                problemDetailsBuilder
+                    .WithTitle("Unknown error. Please see the log for more details.")
+                    .Build()),
+            _ => StatusCode(StatusCodes.Status500InternalServerError, problemDetailsBuilder
+                .WithTitle("Unknown content operation status.")
+                .Build()),
+        });
+
+    protected IActionResult ContentEditingOperationStatusResult<TContentModelBase, TValueModel, TVariantModel>(
+        ContentEditingOperationStatus status,
+        TContentModelBase requestModel,
+        ContentValidationResult validationResult)
+        where TContentModelBase : ContentModelBase<TValueModel, TVariantModel>
+        where TValueModel : ValueModelBase
+        where TVariantModel : VariantModelBase
+    {
+        if (status is not ContentEditingOperationStatus.PropertyValidationError)
+        {
+            return ContentEditingOperationStatusResult(status);
+        }
+
+        var errors = new SortedDictionary<string, string[]>();
+        var missingPropertyAliases = new List<string>();
+        foreach (PropertyValidationError validationError in validationResult.ValidationErrors)
+        {
+            TValueModel? requestValue = requestModel.Values.FirstOrDefault(value =>
+                value.Alias == validationError.Alias
+                && value.Culture == validationError.Culture
+                && value.Segment == validationError.Segment);
+            if (requestValue is null)
+            {
+                missingPropertyAliases.Add(validationError.Alias);
+                continue;
+            }
+
+            var index = requestModel.Values.IndexOf(requestValue);
+            var key = $"$.{nameof(ContentModelBase<TValueModel, TVariantModel>.Values).ToFirstLowerInvariant()}[{index}].{nameof(ValueModelBase.Value).ToFirstLowerInvariant()}{validationError.JsonPath}";
+            errors.Add(key, validationError.ErrorMessages);
+        }
+
+        return OperationStatusResult(status, problemDetailsBuilder
+            => BadRequest(problemDetailsBuilder
+                .WithTitle("Validation failed")
+                .WithDetail("One or more properties did not pass validation")
+                .WithRequestModelErrors(errors)
+                .WithExtension("missingProperties", missingPropertyAliases.ToArray())
+                .Build()));
+    }
+}
@@ -0,0 +1,40 @@
+using System.Globalization;
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Api.Management.ViewModels.Culture;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Culture;
+
+[ApiVersion("1.0")]
+public class AllCultureController : CultureControllerBase
+{
+    private readonly IUmbracoMapper _umbracoMapper;
+
+    public AllCultureController(IUmbracoMapper umbracoMapper) => _umbracoMapper = umbracoMapper;
+
+    /// <summary>
+    ///     Returns all cultures available for creating languages.
+    /// </summary>
+    /// <returns></returns>
+    [HttpGet]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<CultureReponseModel>), StatusCodes.Status200OK)]
+    public async Task<PagedViewModel<CultureReponseModel>> GetAll(int skip = 0, int take = 100)
+    {
+        CultureInfo[] all = CultureInfo.GetCultures(CultureTypes.AllCultures)
+            .DistinctBy(x => x.Name)
+            .OrderBy(x => x.EnglishName)
+            .ToArray();
+
+        var viewModel = new PagedViewModel<CultureReponseModel>
+        {
+            Items = _umbracoMapper.MapEnumerable<CultureInfo, CultureReponseModel>(all.Skip(skip).Take(take)),
+            Total = all.Length
+        };
+
+        return await Task.FromResult(viewModel);
+    }
+}
@@ -0,0 +1,11 @@
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Routing;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Culture;
+
+[ApiController]
+[VersionedApiBackOfficeRoute("culture")]
+[ApiExplorerSettings(GroupName = "Culture")]
+public abstract class CultureControllerBase : ManagementApiControllerBase
+{
+}
@@ -0,0 +1,37 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.DataType;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType;
+
+[ApiVersion("1.0")]
+public class ByKeyDataTypeController : DataTypeControllerBase
+{
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IUmbracoMapper _umbracoMapper;
+
+    public ByKeyDataTypeController(IDataTypeService dataTypeService, IUmbracoMapper umbracoMapper)
+    {
+        _dataTypeService = dataTypeService;
+        _umbracoMapper = umbracoMapper;
+    }
+
+    [HttpGet("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(DataTypeResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> ByKey(Guid id)
+    {
+        IDataType? dataType = await _dataTypeService.GetAsync(id);
+        if (dataType == null)
+        {
+            return DataTypeNotFound();
+        }
+
+        return Ok(_umbracoMapper.Map<DataTypeResponseModel>(dataType));
+    }
+}
@@ -0,0 +1,28 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Api.Management.ViewModels.DataType;
+using Umbraco.Cms.Core.Configuration.Models;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType;
+
+[ApiVersion("1.0")]
+public class ConfigurationDataTypeController : DataTypeControllerBase
+{
+    private readonly DataTypesSettings _dataTypesSettings;
+
+    public ConfigurationDataTypeController(IOptionsSnapshot<DataTypesSettings> dataTypesSettings) => _dataTypesSettings = dataTypesSettings.Value;
+
+    [HttpGet("configuration")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(DatatypeConfigurationResponseModel), StatusCodes.Status200OK)]
+    public Task<IActionResult> Configuration()
+    {
+        var responseModel = new DatatypeConfigurationResponseModel
+        {
+            CanBeChanged = _dataTypesSettings.CanBeChanged,
+        };
+        return Task.FromResult<IActionResult>(Ok());
+    }
+}
@@ -0,0 +1,43 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.DataType;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType;
+
+[ApiVersion("1.0")]
+public class CopyDataTypeController : DataTypeControllerBase
+{
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public CopyDataTypeController(IDataTypeService dataTypeService, IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _dataTypeService = dataTypeService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPost("{id:guid}/copy")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Copy(Guid id, CopyDataTypeRequestModel copyDataTypeRequestModel)
+    {
+        IDataType? source = await _dataTypeService.GetAsync(id);
+        if (source is null)
+        {
+            return DataTypeNotFound();
+        }
+
+        Attempt<IDataType, DataTypeOperationStatus> result = await _dataTypeService.CopyAsync(source, copyDataTypeRequestModel.Target?.Id, CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? CreatedAtId<ByKeyDataTypeController>(controller => nameof(controller.ByKey), result.Result.Key)
+            : DataTypeOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,52 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.DataType;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType;
+
+[ApiVersion("1.0")]
+public class CreateDataTypeController : DataTypeControllerBase
+{
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IDataTypePresentationFactory _dataTypePresentationFactory;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public CreateDataTypeController(IDataTypeService dataTypeService, IDataTypePresentationFactory dataTypePresentationFactory, IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _dataTypeService = dataTypeService;
+        _dataTypePresentationFactory = dataTypePresentationFactory;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPost]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Create(CreateDataTypeRequestModel createDataTypeRequestModel)
+    {
+        var attempt = await _dataTypePresentationFactory.CreateAsync(createDataTypeRequestModel);
+        if (!attempt.Success)
+        {
+            return DataTypeOperationStatusResult(attempt.Status);
+        }
+
+        Attempt<IDataType, DataTypeOperationStatus> result = await _dataTypeService.CreateAsync(attempt.Result, CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? CreatedAtId<ByKeyDataTypeController>(controller => nameof(controller.ByKey), result.Result.Key)
+            : DataTypeOperationStatusResult(result.Status);
+
+
+
+
+
+    }
+}
@@ -0,0 +1,57 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Common.Builders;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType;
+
+[ApiController]
+[VersionedApiBackOfficeRoute(Constants.UdiEntityType.DataType)]
+[ApiExplorerSettings(GroupName = "Data Type")]
+[Authorize(Policy = "New" + AuthorizationPolicies.TreeAccessDocumentsOrDocumentTypes)]
+public abstract class DataTypeControllerBase : ManagementApiControllerBase
+{
+    protected IActionResult DataTypeOperationStatusResult(DataTypeOperationStatus status) =>
+        status switch
+        {
+            DataTypeOperationStatus.InvalidConfiguration => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("Invalid data type configuration")
+                .WithDetail("The supplied data type configuration was not valid. Please see the log for more details.")
+                .Build()),
+            DataTypeOperationStatus.NotFound => DataTypeNotFound(),
+            DataTypeOperationStatus.InvalidName => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("Invalid data type name")
+                .WithDetail("The data type name must be non-empty and no longer than 255 characters.")
+                .Build()),
+            DataTypeOperationStatus.ParentNotContainer => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("parent id is not a container")
+                .WithDetail("The parent id does not represent a container.")
+                .Build()),
+            DataTypeOperationStatus.DuplicateKey => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("The id is already used")
+                .WithDetail("The data type id must be unique.")
+                .Build()),
+            DataTypeOperationStatus.CancelledByNotification => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("Cancelled by notification")
+                .WithDetail("A notification handler prevented the data type operation.")
+                .Build()),
+            DataTypeOperationStatus.PropertyEditorNotFound => NotFound(
+                new ProblemDetailsBuilder()
+                    .WithTitle("The targeted property editor was not found.")
+                    .Build()),
+            DataTypeOperationStatus.ParentNotFound => NotFound(new ProblemDetailsBuilder()
+                    .WithTitle("The targeted parent for the data type operation was not found.")
+                    .Build()),
+            _ => StatusCode(StatusCodes.Status500InternalServerError, new ProblemDetailsBuilder()
+                .WithTitle("Unknown data type operation status.")
+                .Build()),
+        };
+
+    protected IActionResult DataTypeNotFound() => NotFound(new ProblemDetailsBuilder()
+        .WithTitle("The data type could not be found")
+        .Build());
+}
@@ -0,0 +1,37 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType;
+
+[ApiVersion("1.0")]
+public class DeleteDataTypeController : DataTypeControllerBase
+{
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public DeleteDataTypeController(IDataTypeService dataTypeService, IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _dataTypeService = dataTypeService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpDelete("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Delete(Guid id)
+    {
+        Attempt<IDataType?, DataTypeOperationStatus> result = await _dataTypeService.DeleteAsync(id, CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? Ok()
+            : DataTypeOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,25 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Folder;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Folder;
+
+[ApiVersion("1.0")]
+public class ByKeyDataTypeFolderController : DataTypeFolderControllerBase
+{
+    public ByKeyDataTypeFolderController(
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
+        IDataTypeContainerService dataTypeContainerService)
+        : base(backOfficeSecurityAccessor, dataTypeContainerService)
+    {
+    }
+
+    [HttpGet("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(FolderResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> ByKey(Guid id) => await GetFolderAsync(id);
+}
@@ -0,0 +1,29 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Folder;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Folder;
+
+[ApiVersion("1.0")]
+public class CreateDataTypeFolderController : DataTypeFolderControllerBase
+{
+    public CreateDataTypeFolderController(
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
+        IDataTypeContainerService dataTypeContainerService)
+        : base(backOfficeSecurityAccessor, dataTypeContainerService)
+    {
+    }
+
+    [HttpPost]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Create(CreateFolderRequestModel createFolderRequestModel)
+        => await CreateFolderAsync<ByKeyDataTypeFolderController>(
+            createFolderRequestModel,
+            controller => nameof(controller.ByKey));
+}
@@ -0,0 +1,24 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Folder;
+
+[ApiController]
+[VersionedApiBackOfficeRoute($"{Constants.UdiEntityType.DataType}/folder")]
+[ApiExplorerSettings(GroupName = "Data Type")]
+[Authorize(Policy = "New" + AuthorizationPolicies.TreeAccessDocumentTypes)]
+public abstract class DataTypeFolderControllerBase : FolderManagementControllerBase<IDataType>
+{
+    protected DataTypeFolderControllerBase(
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
+        IDataTypeContainerService dataTypeContainerService)
+        : base(backOfficeSecurityAccessor, dataTypeContainerService)
+    {
+    }
+}
@@ -0,0 +1,25 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Folder;
+
+[ApiVersion("1.0")]
+public class DeleteDataTypeFolderController : DataTypeFolderControllerBase
+{
+    public DeleteDataTypeFolderController(
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
+        IDataTypeContainerService dataTypeContainerService)
+        : base(backOfficeSecurityAccessor, dataTypeContainerService)
+    {
+    }
+
+    [HttpDelete("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Delete(Guid id) => await DeleteFolderAsync(id);
+}
@@ -0,0 +1,27 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Folder;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Folder;
+
+[ApiVersion("1.0")]
+public class UpdateDataTypeFolderController : DataTypeFolderControllerBase
+{
+    public UpdateDataTypeFolderController(
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
+        IDataTypeContainerService dataTypeContainerService)
+        : base(backOfficeSecurityAccessor, dataTypeContainerService)
+    {
+    }
+
+    [HttpPut("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Update(Guid id, UpdateFolderResponseModel updateFolderResponseModel)
+        => await UpdateFolderAsync(id, updateFolderResponseModel);
+}
@@ -0,0 +1,32 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType;
+
+[ApiVersion("1.0")]
+public class IsUsedDataTypeController : DataTypeControllerBase
+{
+    private readonly IDataTypeUsageService _dataTypeUsageService;
+
+    public IsUsedDataTypeController(IDataTypeUsageService dataTypeUsageService)
+    {
+        _dataTypeUsageService = dataTypeUsageService;
+    }
+
+    [HttpGet("{id:guid}/is-used")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(bool), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> IsUsed(Guid id)
+    {
+        Attempt<bool, DataTypeOperationStatus> result = await _dataTypeUsageService.HasSavedValuesAsync(id);
+
+        return result.Success
+            ? Ok(result.Result)
+            : DataTypeOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,34 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.DataType.Item;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Item;
+
+[ApiVersion("1.0")]
+public class ByEditorUiAliasController : DatatypeItemControllerBase
+{
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IUmbracoMapper _mapper;
+
+    public ByEditorUiAliasController(
+        IDataTypeService dataTypeService,
+        IUmbracoMapper mapper)
+    {
+        _dataTypeService = dataTypeService;
+        _mapper = mapper;
+    }
+
+    [HttpGet("{*alias}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(DataTypeItemResponseModel), StatusCodes.Status200OK)]
+    public async Task<IActionResult> ByEditorUiAlias(string alias)
+    {
+        IEnumerable<IDataType> dataTypes = await _dataTypeService.GetByEditorUiAlias(alias);
+        List<DataTypeItemResponseModel> responseModels = _mapper.MapEnumerable<IDataType, DataTypeItemResponseModel>(dataTypes);
+        return Ok(responseModels);
+    }
+}
@@ -0,0 +1,15 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Item;
+
+[ApiController]
+[VersionedApiBackOfficeRoute($"{Constants.Web.RoutePath.Item}/{Constants.UdiEntityType.DataType}")]
+[ApiExplorerSettings(GroupName = "Data Type")]
+[Authorize(Policy = "New" + AuthorizationPolicies.TreeAccessDocumentsOrDocumentTypes)]
+public class DatatypeItemControllerBase : ManagementApiControllerBase
+{
+}
@@ -0,0 +1,41 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.DataType.Item;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Item;
+
+[ApiVersion("1.0")]
+public class ItemDatatypeItemController : DatatypeItemControllerBase
+{
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IUmbracoMapper _mapper;
+
+    public ItemDatatypeItemController(IDataTypeService dataTypeService, IUmbracoMapper mapper)
+    {
+        _dataTypeService = dataTypeService;
+        _mapper = mapper;
+    }
+
+    [HttpGet]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(IEnumerable<DataTypeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Item([FromQuery(Name = "id")] HashSet<Guid> ids)
+    {
+        var dataTypes = new List<IDataType>();
+        foreach (Guid id in ids)
+        {
+            IDataType? dataType = await _dataTypeService.GetAsync(id);
+            if (dataType is not null)
+            {
+                dataTypes.Add(dataType);
+            }
+        }
+
+        List<DataTypeItemResponseModel> responseModels = _mapper.MapEnumerable<IDataType, DataTypeItemResponseModel>(dataTypes);
+        return Ok(responseModels);
+    }
+}
@@ -0,0 +1,43 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.DataType;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType;
+
+[ApiVersion("1.0")]
+public class MoveDataTypeController : DataTypeControllerBase
+{
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public MoveDataTypeController(IDataTypeService dataTypeService, IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _dataTypeService = dataTypeService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPut("{id:guid}/move")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Move(Guid id, MoveDataTypeRequestModel moveDataTypeRequestModel)
+    {
+        IDataType? source = await _dataTypeService.GetAsync(id);
+        if (source is null)
+        {
+            return DataTypeNotFound();
+        }
+
+        Attempt<IDataType, DataTypeOperationStatus> result = await _dataTypeService.MoveAsync(source, moveDataTypeRequestModel.Target?.Id, CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? Ok()
+            : DataTypeOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,39 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.DataType;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType;
+
+[ApiVersion("1.0")]
+public class ReferencesDataTypeController : DataTypeControllerBase
+{
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IDataTypeReferencePresentationFactory _dataTypeReferencePresentationFactory;
+
+    public ReferencesDataTypeController(IDataTypeService dataTypeService, IDataTypeReferencePresentationFactory dataTypeReferencePresentationFactory)
+    {
+        _dataTypeService = dataTypeService;
+        _dataTypeReferencePresentationFactory = dataTypeReferencePresentationFactory;
+    }
+
+    [HttpGet("{id:guid}/references")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(DataTypeReferenceResponseModel[]), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> References(Guid id)
+    {
+        Attempt<IReadOnlyDictionary<Udi, IEnumerable<string>>, DataTypeOperationStatus> result = await _dataTypeService.GetReferencesAsync(id);
+        if (result.Success == false)
+        {
+            return DataTypeOperationStatusResult(result.Status);
+        }
+
+        DataTypeReferenceResponseModel[] viewModels = _dataTypeReferencePresentationFactory.CreateDataTypeReferenceViewModels(result.Result).ToArray();
+        return Ok(viewModels);
+    }
+}
@@ -0,0 +1,26 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+using Umbraco.Cms.Api.Management.ViewModels.DataType.Item;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Tree;
+
+[ApiVersion("1.0")]
+public class ChildrenDataTypeTreeController : DataTypeTreeControllerBase
+{
+    public ChildrenDataTypeTreeController(IEntityService entityService, IDataTypeService dataTypeService)
+        : base(entityService, dataTypeService)
+    {
+    }
+
+    [HttpGet("children")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<DataTypeTreeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedViewModel<DataTypeTreeItemResponseModel>>> Children(Guid parentId, int skip = 0, int take = 100, bool foldersOnly = false)
+    {
+        RenderFoldersOnly(foldersOnly);
+        return await GetChildren(parentId, skip, take);
+    }
+}
@@ -0,0 +1,47 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.Controllers.Tree;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Api.Management.ViewModels.DataType.Item;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Tree;
+
+[ApiController]
+[VersionedApiBackOfficeRoute($"{Constants.Web.RoutePath.Tree}/{Constants.UdiEntityType.DataType}")]
+[ApiExplorerSettings(GroupName = "Data Type")]
+[Authorize(Policy = "New" + AuthorizationPolicies.TreeAccessDataTypes)]
+public class DataTypeTreeControllerBase : FolderTreeControllerBase<DataTypeTreeItemResponseModel>
+{
+    private readonly IDataTypeService _dataTypeService;
+
+    public DataTypeTreeControllerBase(IEntityService entityService, IDataTypeService dataTypeService)
+        : base(entityService) =>
+        _dataTypeService = dataTypeService;
+
+    protected override UmbracoObjectTypes ItemObjectType => UmbracoObjectTypes.DataType;
+
+    protected override UmbracoObjectTypes FolderObjectType => UmbracoObjectTypes.DataTypeContainer;
+
+    protected override DataTypeTreeItemResponseModel[] MapTreeItemViewModels(Guid? parentId, IEntitySlim[] entities)
+    {
+        var dataTypes = _dataTypeService
+            .GetAllAsync(entities.Select(entity => entity.Key).ToArray()).GetAwaiter().GetResult()
+            .ToDictionary(contentType => contentType.Id);
+
+        return entities.Select(entity =>
+        {
+            DataTypeTreeItemResponseModel responseModel = MapTreeItemViewModel(parentId, entity);
+            if (dataTypes.TryGetValue(entity.Id, out IDataType? dataType))
+            {
+                responseModel.EditorUiAlias = dataType.EditorUiAlias;
+            }
+
+            return responseModel;
+        }).ToArray();
+    }
+}
@@ -0,0 +1,27 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+using Umbraco.Cms.Api.Management.ViewModels.DataType.Item;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType.Tree;
+
+[ApiVersion("1.0")]
+public class RootDataTypeTreeController : DataTypeTreeControllerBase
+{
+    public RootDataTypeTreeController(IEntityService entityService, IDataTypeService dataTypeService)
+        : base(entityService, dataTypeService)
+    {
+    }
+
+    [HttpGet("root")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<DataTypeTreeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedViewModel<DataTypeTreeItemResponseModel>>> Root(int skip = 0, int take = 100, bool foldersOnly = false)
+    {
+        RenderFoldersOnly(foldersOnly);
+        return await GetRoot(skip, take);
+    }
+}
@@ -0,0 +1,52 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.DataType;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.DataType;
+
+[ApiVersion("1.0")]
+public class UpdateDataTypeController : DataTypeControllerBase
+{
+    private readonly IDataTypeService _dataTypeService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+    private IDataTypePresentationFactory _dataTypePresentationFactory;
+
+    public UpdateDataTypeController(IDataTypeService dataTypeService, IBackOfficeSecurityAccessor backOfficeSecurityAccessor, IDataTypePresentationFactory dataTypePresentationFactory)
+    {
+        _dataTypeService = dataTypeService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+        _dataTypePresentationFactory = dataTypePresentationFactory;
+    }
+
+    [HttpPut("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Update(Guid id, UpdateDataTypeRequestModel updateDataTypeViewModel)
+    {
+        IDataType? current = await _dataTypeService.GetAsync(id);
+        if (current == null)
+        {
+            return DataTypeNotFound();
+        }
+
+        Attempt<IDataType, DataTypeOperationStatus> attempt = await _dataTypePresentationFactory.CreateAsync(updateDataTypeViewModel, current);
+        if (!attempt.Success)
+        {
+            return DataTypeOperationStatusResult(attempt.Status);
+        }
+
+        Attempt<IDataType, DataTypeOperationStatus> result = await _dataTypeService.UpdateAsync(attempt.Result, CurrentUserKey(_backOfficeSecurityAccessor));
+        return result.Success
+            ? Ok()
+            : DataTypeOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,39 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.ViewModels.Dictionary;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+using Umbraco.Cms.Core;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary;
+
+[ApiVersion("1.0")]
+public class AllDictionaryController : DictionaryControllerBase
+{
+    private readonly IDictionaryItemService _dictionaryItemService;
+    private readonly IUmbracoMapper _umbracoMapper;
+
+    public AllDictionaryController(IDictionaryItemService dictionaryItemService, IUmbracoMapper umbracoMapper)
+    {
+        _dictionaryItemService = dictionaryItemService;
+        _umbracoMapper = umbracoMapper;
+    }
+
+    [HttpGet]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<DictionaryOverviewResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedViewModel<DictionaryOverviewResponseModel>>> All(int skip = 0, int take = 100)
+    {
+        // unfortunately we can't paginate here...we'll have to get all and paginate in memory
+        IDictionaryItem[] items = (await _dictionaryItemService.GetDescendantsAsync(Constants.System.RootKey)).ToArray();
+        var model = new PagedViewModel<DictionaryOverviewResponseModel>
+        {
+            Total = items.Length,
+            Items = _umbracoMapper.MapEnumerable<IDictionaryItem, DictionaryOverviewResponseModel>(items.Skip(skip).Take(take))
+        };
+        return await Task.FromResult(model);
+    }
+}
@@ -0,0 +1,37 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.ViewModels.Dictionary;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary;
+
+[ApiVersion("1.0")]
+public class ByKeyDictionaryController : DictionaryControllerBase
+{
+    private readonly IDictionaryItemService _dictionaryItemService;
+    private readonly IDictionaryPresentationFactory _dictionaryPresentationFactory;
+
+    public ByKeyDictionaryController(IDictionaryItemService dictionaryItemService, IDictionaryPresentationFactory dictionaryPresentationFactory)
+    {
+        _dictionaryItemService = dictionaryItemService;
+        _dictionaryPresentationFactory = dictionaryPresentationFactory;
+    }
+
+    [HttpGet($"{{{nameof(id)}:guid}}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(DictionaryItemResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> ByKey(Guid id)
+    {
+        IDictionaryItem? dictionary = await _dictionaryItemService.GetAsync(id);
+        if (dictionary == null)
+        {
+            return DictionaryNotFound();
+        }
+
+        return Ok(await _dictionaryPresentationFactory.CreateDictionaryItemViewModelAsync(dictionary));
+    }
+}
@@ -0,0 +1,65 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.Security.Authorization.Dictionary;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.ViewModels.Dictionary;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary;
+
+[ApiVersion("1.0")]
+public class CreateDictionaryController : DictionaryControllerBase
+{
+    private readonly IDictionaryItemService _dictionaryItemService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+    private readonly IDictionaryPresentationFactory _dictionaryPresentationFactory;
+    private readonly IAuthorizationService _authorizationService;
+
+    public CreateDictionaryController(
+        IDictionaryItemService dictionaryItemService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
+        IDictionaryPresentationFactory dictionaryPresentationFactory,
+        IAuthorizationService authorizationService)
+    {
+        _dictionaryItemService = dictionaryItemService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+        _dictionaryPresentationFactory = dictionaryPresentationFactory;
+        _authorizationService = authorizationService;
+    }
+
+    [HttpPost]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status409Conflict)]
+    public async Task<IActionResult> Create(CreateDictionaryItemRequestModel createDictionaryItemRequestModel)
+    {
+        IDictionaryItem created = await _dictionaryPresentationFactory.MapCreateModelToDictionaryItemAsync(createDictionaryItemRequestModel);
+
+        AuthorizationResult authorizationResult  = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            new DictionaryPermissionResource(createDictionaryItemRequestModel.Translations.Select(t => t.IsoCode)),
+            AuthorizationPolicies.DictionaryPermissionByResource);
+
+        if (authorizationResult.Succeeded is false)
+        {
+            return Forbidden();
+        }
+
+        Attempt<IDictionaryItem, DictionaryItemOperationStatus> result =
+            await _dictionaryItemService.CreateAsync(created, CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? CreatedAtId<ByKeyDictionaryController>(controller => nameof(controller.ByKey), result.Result!.Key)
+            : DictionaryItemOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,37 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary;
+
+[ApiVersion("1.0")]
+public class DeleteDictionaryController : DictionaryControllerBase
+{
+    private readonly IDictionaryItemService _dictionaryItemService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public DeleteDictionaryController(IDictionaryItemService dictionaryItemService, IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _dictionaryItemService = dictionaryItemService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpDelete($"{{{nameof(id)}:guid}}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Delete(Guid id)
+    {
+        Attempt<IDictionaryItem?, DictionaryItemOperationStatus> result = await _dictionaryItemService.DeleteAsync(id, CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? Ok()
+            : DictionaryItemOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,45 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Common.Builders;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary;
+
+[ApiController]
+[VersionedApiBackOfficeRoute("dictionary")]
+[ApiExplorerSettings(GroupName = "Dictionary")]
+[Authorize(Policy = "New" + AuthorizationPolicies.TreeAccessDictionary)]
+public abstract class DictionaryControllerBase : ManagementApiControllerBase
+{
+    protected IActionResult DictionaryItemOperationStatusResult(DictionaryItemOperationStatus status) =>
+        status switch
+        {
+            DictionaryItemOperationStatus.DuplicateItemKey => Conflict(new ProblemDetailsBuilder()
+                .WithTitle("Duplicate dictionary item name detected")
+                .WithDetail("Another dictionary item exists with the same name. Dictionary item names must be unique.")
+                .Build()),
+            DictionaryItemOperationStatus.ItemNotFound => DictionaryNotFound(),
+            DictionaryItemOperationStatus.ParentNotFound => NotFound(new ProblemDetailsBuilder()
+                    .WithTitle("The dictionary item parent could not be found")
+                    .Build()),
+            DictionaryItemOperationStatus.CancelledByNotification => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("Cancelled by notification")
+                .WithDetail("A notification handler prevented the dictionary item operation.")
+                .Build()),
+            DictionaryItemOperationStatus.InvalidParent => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("Invalid parent")
+                .WithDetail("The targeted parent dictionary item is not valid for this dictionary item operation.")
+                .Build()),
+            _ => StatusCode(StatusCodes.Status500InternalServerError, new ProblemDetailsBuilder()
+                .WithTitle("Unknown dictionary operation status.")
+                .Build()),
+        };
+
+
+    protected IActionResult DictionaryNotFound() => NotFound(new ProblemDetailsBuilder()
+        .WithTitle("The dictionary item could not be found")
+        .Build());
+}
@@ -0,0 +1,41 @@
+using System.Net.Mime;
+using System.Text;
+using System.Xml.Linq;
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary;
+
+[ApiVersion("1.0")]
+public class ExportDictionaryController : DictionaryControllerBase
+{
+    private readonly IDictionaryItemService _dictionaryItemService;
+    private readonly IEntityXmlSerializer _entityXmlSerializer;
+
+    public ExportDictionaryController(IDictionaryItemService dictionaryItemService, IEntityXmlSerializer entityXmlSerializer)
+    {
+        _dictionaryItemService = dictionaryItemService;
+        _entityXmlSerializer = entityXmlSerializer;
+    }
+
+    [HttpGet("{id:guid}/export")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(FileContentResult), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Export(Guid id, bool includeChildren = false)
+    {
+        IDictionaryItem? dictionaryItem = await _dictionaryItemService.GetAsync(id);
+        if (dictionaryItem is null)
+        {
+            return DictionaryNotFound();
+        }
+
+        XElement xml = _entityXmlSerializer.Serialize(dictionaryItem, includeChildren);
+
+        return File(Encoding.UTF8.GetBytes(xml.ToDataString()), MediaTypeNames.Application.Octet, $"{dictionaryItem.ItemKey}.udt");
+    }
+}
@@ -0,0 +1,63 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Common.Builders;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Api.Management.Services;
+using Umbraco.Cms.Api.Management.Services.OperationStatus;
+using Umbraco.Cms.Api.Management.ViewModels.Dictionary;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Security;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary;
+
+[ApiVersion("1.0")]
+public class ImportDictionaryController : DictionaryControllerBase
+{
+    private readonly IDictionaryItemImportService _dictionaryItemImportService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public ImportDictionaryController(
+        IDictionaryItemImportService dictionaryItemImportService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _dictionaryItemImportService = dictionaryItemImportService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPost("import")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Import(ImportDictionaryRequestModel importDictionaryRequestModel)
+    {
+        Attempt<IDictionaryItem?, DictionaryImportOperationStatus> result = await _dictionaryItemImportService
+            .ImportDictionaryItemFromUdtFileAsync(
+                importDictionaryRequestModel.TemporaryFile.Id,
+                importDictionaryRequestModel.Parent?.Id,
+                CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Status switch
+        {
+            DictionaryImportOperationStatus.Success => CreatedAtId<ByKeyDictionaryController>(controller => nameof(controller.ByKey), result.Result!.Key),
+            DictionaryImportOperationStatus.ParentNotFound => NotFound(new ProblemDetailsBuilder()
+                    .WithTitle("The parent dictionary item could not be found.")
+                    .Build()),
+            DictionaryImportOperationStatus.TemporaryFileNotFound => NotFound(new ProblemDetailsBuilder()
+                    .WithTitle("The temporary file with specified id could not be found.")
+                    .Build()),
+            DictionaryImportOperationStatus.InvalidFileType => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("Invalid file type")
+                .WithDetail("The dictionary import only supports UDT files.")
+                .Build()),
+            DictionaryImportOperationStatus.InvalidFileContent => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("Invalid file content")
+                .WithDetail("The uploaded file could not be read as a valid UDT file.")
+                .Build()),
+            _ => StatusCode(StatusCodes.Status500InternalServerError, new ProblemDetailsBuilder()
+                .WithTitle("Unknown dictionary import operation status.")
+                .Build()),
+        };
+    }
+}
@@ -0,0 +1,15 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary.Item;
+
+[ApiController]
+[VersionedApiBackOfficeRoute($"{Constants.Web.RoutePath.Item}/dictionary")]
+[ApiExplorerSettings(GroupName = "Dictionary")]
+[Authorize(Policy = "New" + AuthorizationPolicies.TreeAccessDictionary)]
+public class DictionaryItemControllerBase : ManagementApiControllerBase
+{
+}
@@ -0,0 +1,33 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Dictionary.Item;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary.Item;
+
+[ApiVersion("1.0")]
+public class ItemDictionaryItemController : DictionaryItemControllerBase
+{
+    private readonly IDictionaryItemService _dictionaryItemService;
+    private readonly IUmbracoMapper _mapper;
+
+    public ItemDictionaryItemController(IDictionaryItemService dictionaryItemService, IUmbracoMapper mapper)
+    {
+        _dictionaryItemService = dictionaryItemService;
+        _mapper = mapper;
+    }
+
+    [HttpGet]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(IEnumerable<DictionaryItemItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Item([FromQuery(Name = "id")] HashSet<Guid> ids)
+    {
+        IEnumerable<IDictionaryItem> dictionaryItems = await _dictionaryItemService.GetManyAsync(ids.ToArray());
+
+        List<DictionaryItemItemResponseModel> responseModels = _mapper.MapEnumerable<IDictionaryItem, DictionaryItemItemResponseModel>(dictionaryItems);
+        return Ok(responseModels);
+    }
+}
@@ -0,0 +1,47 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Dictionary;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary;
+
+[ApiVersion("1.0")]
+public class MoveDictionaryController : DictionaryControllerBase
+{
+    private readonly IDictionaryItemService _dictionaryItemService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public MoveDictionaryController(IDictionaryItemService dictionaryItemService, IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _dictionaryItemService = dictionaryItemService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPut("{id:guid}/move")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Move(Guid id, MoveDictionaryRequestModel moveDictionaryRequestModel)
+    {
+        IDictionaryItem? source = await _dictionaryItemService.GetAsync(id);
+        if (source == null)
+        {
+            return DictionaryNotFound();
+        }
+
+        Attempt<IDictionaryItem, DictionaryItemOperationStatus> result = await _dictionaryItemService.MoveAsync(
+            source,
+            moveDictionaryRequestModel.Target?.Id,
+            CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? Ok()
+            : DictionaryItemOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,34 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.Services.Paging;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary.Tree;
+
+[ApiVersion("1.0")]
+public class ChildrenDictionaryTreeController : DictionaryTreeControllerBase
+{
+    public ChildrenDictionaryTreeController(IEntityService entityService, IDictionaryItemService dictionaryItemService)
+        : base(entityService, dictionaryItemService)
+    {
+    }
+
+    [HttpGet("children")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<NamedEntityTreeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedViewModel<NamedEntityTreeItemResponseModel>>> Children(Guid parentId, int skip = 0, int take = 100)
+    {
+        if (PaginationService.ConvertSkipTakeToPaging(skip, take, out var pageNumber, out var pageSize, out ProblemDetails? error) == false)
+        {
+            return BadRequest(error);
+        }
+
+        PagedModel<IDictionaryItem> paginatedItems = await DictionaryItemService.GetPagedAsync(parentId, skip, take);
+
+        return Ok(PagedViewModel(await MapTreeItemViewModels(parentId, paginatedItems.Items), paginatedItems.Total));
+    }
+}
@@ -0,0 +1,53 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.Controllers.Tree;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Api.Management.ViewModels;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary.Tree;
+
+[ApiController]
+[VersionedApiBackOfficeRoute($"{Constants.Web.RoutePath.Tree}/dictionary")]
+[ApiExplorerSettings(GroupName = "Dictionary")]
+[Authorize(Policy = "New" + AuthorizationPolicies.TreeAccessDictionaryOrTemplates)]
+// NOTE: at the moment dictionary items (renamed to dictionary tree) aren't supported by EntityService, so we have little use of the
+// tree controller base. We'll keep it though, in the hope that we can mend EntityService.
+public class DictionaryTreeControllerBase : NamedEntityTreeControllerBase<NamedEntityTreeItemResponseModel>
+{
+    public DictionaryTreeControllerBase(IEntityService entityService, IDictionaryItemService dictionaryItemService)
+        : base(entityService) =>
+        DictionaryItemService = dictionaryItemService;
+
+    // dictionary items do not currently have a known UmbracoObjectType, so we'll settle with Unknown for now
+    protected override UmbracoObjectTypes ItemObjectType => UmbracoObjectTypes.Unknown;
+
+    protected IDictionaryItemService DictionaryItemService { get; }
+
+    protected async Task<IEnumerable<NamedEntityTreeItemResponseModel>> MapTreeItemViewModels(Guid? parentKey, IEnumerable<IDictionaryItem> dictionaryItems)
+    {
+        async Task<NamedEntityTreeItemResponseModel> CreateEntityTreeItemViewModelAsync(IDictionaryItem dictionaryItem)
+        {
+            var hasChildren = await DictionaryItemService.CountChildrenAsync(dictionaryItem.Key) > 0;
+            return new NamedEntityTreeItemResponseModel
+            {
+                Name = dictionaryItem.ItemKey,
+                Id = dictionaryItem.Key,
+                Type = Constants.UdiEntityType.DictionaryItem,
+                HasChildren = hasChildren,
+                Parent = parentKey.HasValue
+                    ? new ReferenceByIdModel
+                    {
+                        Id = parentKey.Value
+                    }
+                    : null
+            };
+        }
+
+        return await Task.WhenAll(dictionaryItems.Select(CreateEntityTreeItemViewModelAsync));
+    }
+}
@@ -0,0 +1,34 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.Services.Paging;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary.Tree;
+
+[ApiVersion("1.0")]
+public class RootDictionaryTreeController : DictionaryTreeControllerBase
+{
+    public RootDictionaryTreeController(IEntityService entityService, IDictionaryItemService dictionaryItemService)
+        : base(entityService, dictionaryItemService)
+    {
+    }
+
+    [HttpGet("root")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<NamedEntityTreeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedViewModel<NamedEntityTreeItemResponseModel>>> Root(int skip = 0, int take = 100)
+    {
+        if (PaginationService.ConvertSkipTakeToPaging(skip, take, out var pageNumber, out var pageSize, out ProblemDetails? error) == false)
+        {
+            return BadRequest(error);
+        }
+
+        PagedModel<IDictionaryItem> paginatedItems = await DictionaryItemService.GetPagedAsync(null, skip, take);
+
+        return Ok(PagedViewModel(await MapTreeItemViewModels(null, paginatedItems.Items), paginatedItems.Total));
+    }
+}
@@ -0,0 +1,70 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.Security.Authorization.Dictionary;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.ViewModels.Dictionary;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Dictionary;
+
+[ApiVersion("1.0")]
+public class UpdateDictionaryController : DictionaryControllerBase
+{
+    private readonly IDictionaryItemService _dictionaryItemService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+    private readonly IDictionaryPresentationFactory _dictionaryPresentationFactory;
+    private readonly IAuthorizationService _authorizationService;
+
+    public UpdateDictionaryController(
+        IDictionaryItemService dictionaryItemService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
+        IDictionaryPresentationFactory dictionaryPresentationFactory,
+        IAuthorizationService authorizationService)
+    {
+        _dictionaryItemService = dictionaryItemService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+        _dictionaryPresentationFactory = dictionaryPresentationFactory;
+        _authorizationService = authorizationService;
+    }
+
+    [HttpPut($"{{{nameof(id)}:guid}}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Update(Guid id, UpdateDictionaryItemRequestModel updateDictionaryItemRequestModel)
+    {
+        IDictionaryItem? current = await _dictionaryItemService.GetAsync(id);
+        if (current == null)
+        {
+            return DictionaryNotFound();
+        }
+
+        AuthorizationResult authorizationResult  = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            new DictionaryPermissionResource(updateDictionaryItemRequestModel.Translations.Select(t => t.IsoCode)),
+            AuthorizationPolicies.DictionaryPermissionByResource);
+
+        if (authorizationResult.Succeeded is false)
+        {
+            return Forbidden();
+        }
+
+        IDictionaryItem updated = await _dictionaryPresentationFactory.MapUpdateModelToDictionaryItemAsync(current, updateDictionaryItemRequestModel);
+
+        Attempt<IDictionaryItem, DictionaryItemOperationStatus> result =
+            await _dictionaryItemService.UpdateAsync(updated, CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? Ok()
+            : DictionaryItemOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,58 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class ByKeyDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentEditingService _contentEditingService;
+    private readonly IDocumentPresentationFactory _documentPresentationFactory;
+
+    public ByKeyDocumentController(
+        IAuthorizationService authorizationService,
+        IContentEditingService contentEditingService,
+        IDocumentPresentationFactory documentPresentationFactory)
+    {
+        _authorizationService = authorizationService;
+        _contentEditingService = contentEditingService;
+        _documentPresentationFactory = documentPresentationFactory;
+    }
+
+    [HttpGet("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(DocumentResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> ByKey(Guid id)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionBrowse.ActionLetter, id),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        IContent? content = await _contentEditingService.GetAsync(id);
+        if (content == null)
+        {
+            return DocumentNotFound();
+        }
+
+        DocumentResponseModel model = await _documentPresentationFactory.CreateResponseModelAsync(content);
+        return Ok(model);
+    }
+}
@@ -0,0 +1,36 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core.Configuration.Models;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class ConfigurationDocumentController : DocumentControllerBase
+{
+    private readonly GlobalSettings _globalSettings;
+    private readonly ContentSettings _contentSettings;
+
+    public ConfigurationDocumentController(IOptionsSnapshot<GlobalSettings> globalSettings, IOptionsSnapshot<ContentSettings> contentSettings)
+    {
+        _contentSettings = contentSettings.Value;
+        _globalSettings = globalSettings.Value;
+    }
+
+    [HttpGet("configuration")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(DocumentConfigurationResponseModel), StatusCodes.Status200OK)]
+    public Task<IActionResult> Configuration()
+    {
+        var responseModel = new DocumentConfigurationResponseModel
+        {
+            DisableDeleteWhenReferenced = _contentSettings.DisableDeleteWhenReferenced,
+            DisableUnpublishWhenReferenced = _contentSettings.DisableUnpublishWhenReferenced,
+            SanitizeTinyMce = _globalSettings.SanitizeTinyMce,
+            AllowEditInvariantFromNonDefault = _contentSettings.AllowEditInvariantFromNonDefault,
+        };
+        return Task.FromResult<IActionResult>(Ok(responseModel));
+    }
+}
@@ -0,0 +1,62 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class CopyDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentEditingService _contentEditingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public CopyDocumentController(
+        IAuthorizationService authorizationService,
+        IContentEditingService contentEditingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _authorizationService = authorizationService;
+        _contentEditingService = contentEditingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPost("{id:guid}/copy")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Copy(Guid id, CopyDocumentRequestModel copyDocumentRequestModel)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionCopy.ActionLetter, new[] { copyDocumentRequestModel.Target?.Id, id }),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<IContent?, ContentEditingOperationStatus> result = await _contentEditingService.CopyAsync(
+            id,
+            copyDocumentRequestModel.Target?.Id,
+            copyDocumentRequestModel.RelateToOriginal,
+            copyDocumentRequestModel.IncludeDescendants,
+            CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? CreatedAtId<ByKeyDocumentController>(controller => nameof(controller.ByKey), result.Result!.Key)
+            : ContentEditingOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,50 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models.ContentEditing;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class CreateDocumentController : CreateDocumentControllerBase
+{
+    private readonly IDocumentEditingPresentationFactory _documentEditingPresentationFactory;
+    private readonly IContentEditingService _contentEditingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public CreateDocumentController(
+        IAuthorizationService authorizationService,
+        IDocumentEditingPresentationFactory documentEditingPresentationFactory,
+        IContentEditingService contentEditingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+        : base(authorizationService)
+    {
+        _documentEditingPresentationFactory = documentEditingPresentationFactory;
+        _contentEditingService = contentEditingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPost]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Create(CreateDocumentRequestModel requestModel)
+        => await HandleRequest(requestModel, async () =>
+        {
+            ContentCreateModel model = _documentEditingPresentationFactory.MapCreateModel(requestModel);
+            Attempt<ContentCreateResult, ContentEditingOperationStatus> result =
+                await _contentEditingService.CreateAsync(model, CurrentUserKey(_backOfficeSecurityAccessor));
+
+            return result.Success
+                ? CreatedAtId<ByKeyDocumentController>(controller => nameof(controller.ByKey), result.Result.Content!.Key)
+                : ContentEditingOperationStatusResult(result.Status);
+        });
+}
@@ -0,0 +1,35 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+public abstract class CreateDocumentControllerBase : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+
+    protected CreateDocumentControllerBase(IAuthorizationService authorizationService)
+        => _authorizationService = authorizationService;
+
+    protected async Task<IActionResult> HandleRequest(CreateDocumentRequestModel requestModel, Func<Task<IActionResult>> authorizedHandler)
+    {
+        IEnumerable<string> cultures = requestModel.Variants
+            .Where(v => v.Culture is not null)
+            .Select(v => v.Culture!);
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionNew.ActionLetter, requestModel.Parent?.Id, cultures),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        return await authorizedHandler();
+    }
+}
@@ -0,0 +1,59 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.PublicAccess;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class CreatePublicAccessDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IPublicAccessPresentationFactory _publicAccessPresentationFactory;
+    private readonly IPublicAccessService _publicAccessService;
+
+    public CreatePublicAccessDocumentController(
+        IAuthorizationService authorizationService,
+        IPublicAccessPresentationFactory publicAccessPresentationFactory,
+        IPublicAccessService publicAccessService)
+    {
+        _authorizationService = authorizationService;
+        _publicAccessPresentationFactory = publicAccessPresentationFactory;
+        _publicAccessService = publicAccessService;
+    }
+
+    [MapToApiVersion("1.0")]
+    [HttpPost("{id:guid}/public-access")]
+    [ProducesResponseType(StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Create(Guid id, PublicAccessRequestModel publicAccessRequestModel)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionProtect.ActionLetter, id),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        PublicAccessEntrySlim publicAccessEntrySlim = _publicAccessPresentationFactory.CreatePublicAccessEntrySlim(publicAccessRequestModel, id);
+
+        Attempt<PublicAccessEntry?, PublicAccessOperationStatus> saveAttempt = await _publicAccessService.CreateAsync(publicAccessEntrySlim);
+
+        return saveAttempt.Success
+            ? CreatedAtId<GetPublicAccessDocumentController>(controller => nameof(controller.GetPublicAccess), saveAttempt.Result!.Key)
+            : PublicAccessOperationStatusResult(saveAttempt.Status);
+    }
+}
@@ -0,0 +1,57 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class DeleteDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentEditingService _contentEditingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public DeleteDocumentController(
+        IAuthorizationService authorizationService,
+        IContentEditingService contentEditingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _authorizationService = authorizationService;
+        _contentEditingService = contentEditingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpDelete("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Delete(Guid id)
+    {
+        AuthorizationResult authorizationResult  = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionDelete.ActionLetter, id),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<IContent?, ContentEditingOperationStatus> result = await _contentEditingService.DeleteAsync(id, CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? Ok()
+            : ContentEditingOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,47 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class DeletePublicAccessDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IPublicAccessService _publicAccessService;
+
+    public DeletePublicAccessDocumentController(IAuthorizationService authorizationService, IPublicAccessService publicAccessService)
+    {
+        _authorizationService = authorizationService;
+        _publicAccessService = publicAccessService;
+    }
+
+    [MapToApiVersion("1.0")]
+    [HttpDelete("{id:guid}/public-access")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Delete(Guid id)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionProtect.ActionLetter, id),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<PublicAccessOperationStatus> attempt = await _publicAccessService.DeleteAsync(id);
+
+        return attempt.Success ? Ok() : PublicAccessOperationStatusResult(attempt.Result);
+    }
+}
@@ -0,0 +1,144 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Controllers.Content;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Api.Management.ViewModels.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models.ContentEditing;
+using Umbraco.Cms.Core.Models.ContentPublishing;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiController]
+[VersionedApiBackOfficeRoute(Constants.UdiEntityType.Document)]
+[ApiExplorerSettings(GroupName = nameof(Constants.UdiEntityType.Document))]
+[Authorize(Policy = "New" + AuthorizationPolicies.TreeAccessDocuments)]
+public abstract class DocumentControllerBase : ContentControllerBase
+{
+    protected IActionResult DocumentNotFound()
+        => OperationStatusResult(ContentEditingOperationStatus.NotFound, problemDetailsBuilder
+            => NotFound(problemDetailsBuilder
+                .WithTitle("The document could not be found")
+                .Build()));
+
+    protected IActionResult DocumentEditingOperationStatusResult<TContentModelBase>(
+        ContentEditingOperationStatus status,
+        TContentModelBase requestModel,
+        ContentValidationResult validationResult)
+        where TContentModelBase : ContentModelBase<DocumentValueModel, DocumentVariantRequestModel>
+        => ContentEditingOperationStatusResult<TContentModelBase, DocumentValueModel, DocumentVariantRequestModel>(status, requestModel, validationResult);
+
+    protected IActionResult DocumentPublishingOperationStatusResult(
+        ContentPublishingOperationStatus status,
+        IEnumerable<string>? invalidPropertyAliases = null,
+        IEnumerable<ContentPublishingBranchItemResult>? failedBranchItems = null)
+        => OperationStatusResult(status, problemDetailsBuilder => status switch
+        {
+            ContentPublishingOperationStatus.ContentNotFound => NotFound(problemDetailsBuilder
+                .WithTitle("The requested document could not be found")
+                .Build()),
+            ContentPublishingOperationStatus.CancelledByEvent => BadRequest(problemDetailsBuilder
+                .WithTitle("Publish cancelled by event")
+                .WithDetail("The publish operation was cancelled by an event.")
+                .Build()),
+            ContentPublishingOperationStatus.ContentInvalid => BadRequest(problemDetailsBuilder
+                .WithTitle("Invalid document")
+                .WithDetail("The specified document had an invalid configuration.")
+                .WithExtension("invalidProperties", invalidPropertyAliases ?? Enumerable.Empty<string>())
+                .Build()),
+            ContentPublishingOperationStatus.NothingToPublish => BadRequest(problemDetailsBuilder
+                .WithTitle("Nothing to publish")
+                .WithDetail("None of the specified cultures needed publishing.")
+                .Build()),
+            ContentPublishingOperationStatus.MandatoryCultureMissing => BadRequest(problemDetailsBuilder
+                .WithTitle("Mandatory culture missing")
+                .WithDetail("Must include all mandatory cultures when publishing.")
+                .Build()),
+            ContentPublishingOperationStatus.HasExpired => BadRequest(problemDetailsBuilder
+                .WithTitle("Document expired")
+                .WithDetail("Could not publish the document because it was expired.")
+                .Build()),
+            ContentPublishingOperationStatus.CultureHasExpired => BadRequest(problemDetailsBuilder
+                .WithTitle("Document culture expired")
+                .WithDetail("Could not publish the document because some of the specified cultures were expired.")
+                .Build()),
+            ContentPublishingOperationStatus.AwaitingRelease => BadRequest(problemDetailsBuilder
+                .WithTitle("Document awaiting release")
+                .WithDetail("Could not publish the document because it was awaiting release.")
+                .Build()),
+            ContentPublishingOperationStatus.CultureAwaitingRelease => BadRequest(problemDetailsBuilder
+                .WithTitle("Document culture awaiting release")
+                .WithDetail(
+                    "Could not publish the document because some of the specified cultures were awaiting release.")
+                .Build()),
+            ContentPublishingOperationStatus.InTrash => BadRequest(problemDetailsBuilder
+                .WithTitle("Document in the recycle bin")
+                .WithDetail("Could not publish the document because it was in the recycle bin.")
+                .Build()),
+            ContentPublishingOperationStatus.PathNotPublished => BadRequest(problemDetailsBuilder
+                .WithTitle("Parent not published")
+                .WithDetail("Could not publish the document because its parent was not published.")
+                .Build()),
+            ContentPublishingOperationStatus.ConcurrencyViolation => BadRequest(problemDetailsBuilder
+                .WithTitle("Concurrency violation detected")
+                .WithDetail("An attempt was made to publish a version older than the latest version.")
+                .Build()),
+            ContentPublishingOperationStatus.UnsavedChanges => BadRequest(problemDetailsBuilder
+                .WithTitle("Unsaved changes")
+                .WithDetail(
+                    "Could not publish the document because it had unsaved changes. Make sure to save all changes before attempting a publish.")
+                .Build()),
+            ContentPublishingOperationStatus.FailedBranch => BadRequest(problemDetailsBuilder
+                .WithTitle("Failed branch operation")
+                .WithDetail("One or more items in the branch could not complete the operation.")
+                .WithExtension("failedBranchItems", failedBranchItems?.Select(item => new DocumentPublishBranchItemResult
+                    {
+                        Id = item.Key,
+                        OperationStatus = item.OperationStatus
+                    }) ?? Enumerable.Empty<DocumentPublishBranchItemResult>())
+                .Build()),
+            ContentPublishingOperationStatus.Failed => BadRequest(problemDetailsBuilder
+                .WithTitle("Publish or unpublish failed")
+                .WithDetail(
+                    "An unspecified error occurred while (un)publishing. Please check the logs for additional information.")
+                .Build()),
+            _ => StatusCode(StatusCodes.Status500InternalServerError, "Unknown content operation status."),
+        });
+
+    protected IActionResult PublicAccessOperationStatusResult(PublicAccessOperationStatus status)
+        => OperationStatusResult(status, problemDetailsBuilder => status switch
+        {
+            PublicAccessOperationStatus.ContentNotFound => NotFound(problemDetailsBuilder
+                .WithTitle("The document could not be found")
+                .Build()),
+            PublicAccessOperationStatus.ErrorNodeNotFound => NotFound(problemDetailsBuilder
+                .WithTitle("The error page could not be found")
+                .Build()),
+            PublicAccessOperationStatus.LoginNodeNotFound => NotFound(problemDetailsBuilder
+                .WithTitle("The login page could not be found")
+                .Build()),
+            PublicAccessOperationStatus.NoAllowedEntities => BadRequest(problemDetailsBuilder
+                .WithTitle("No allowed entities given")
+                .WithDetail("Both MemberGroups and Members were empty, thus no entities can be allowed.")
+                .Build()),
+            PublicAccessOperationStatus.CancelledByNotification => BadRequest(problemDetailsBuilder
+                .WithTitle("Request cancelled by notification")
+                .WithDetail("The request to save a public access entry was cancelled by a notification handler.")
+                .Build()),
+            PublicAccessOperationStatus.AmbiguousRule => BadRequest(problemDetailsBuilder
+                .WithTitle("Ambiguous Rule")
+                .WithDetail("The specified rule is ambiguous, because both member groups and member names were given.")
+                .Build()),
+            PublicAccessOperationStatus.EntryNotFound => BadRequest(problemDetailsBuilder
+                .WithTitle("Entry not found")
+                .WithDetail("The specified entry was not found.")
+                .Build()),
+            _ => StatusCode(StatusCodes.Status500InternalServerError, problemDetailsBuilder
+                .WithTitle("Unknown content operation status.")
+                .Build()),
+        });
+}
@@ -0,0 +1,36 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class DomainsController : DocumentControllerBase
+{
+    private readonly IDomainService _domainService;
+    private readonly IUmbracoMapper _umbracoMapper;
+
+    public DomainsController(IDomainService domainService, IUmbracoMapper umbracoMapper)
+    {
+        _domainService = domainService;
+        _umbracoMapper = umbracoMapper;
+    }
+
+    [MapToApiVersion("1.0")]
+    [HttpGet("{id:guid}/domains")]
+    [ProducesResponseType(typeof(DomainsResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Domains(Guid id)
+    {
+        IDomain[] assignedDomains = (await _domainService.GetAssignedDomainsAsync(id, true))
+            .OrderBy(d => d.SortOrder)
+            .ToArray();
+
+        DomainsResponseModel responseModel = _umbracoMapper.Map<DomainsResponseModel>(assignedDomains)!;
+        return Ok(responseModel);
+    }
+}
@@ -0,0 +1,73 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.PublicAccess;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class GetPublicAccessDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IPublicAccessService _publicAccessService;
+    private readonly IPublicAccessPresentationFactory _publicAccessPresentationFactory;
+
+    public GetPublicAccessDocumentController(
+        IAuthorizationService authorizationService,
+        IPublicAccessService publicAccessService,
+        IPublicAccessPresentationFactory publicAccessPresentationFactory)
+    {
+        _authorizationService = authorizationService;
+        _publicAccessService = publicAccessService;
+        _publicAccessPresentationFactory = publicAccessPresentationFactory;
+    }
+
+    [MapToApiVersion("1.0")]
+    [HttpGet("{id:guid}/public-access")]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetPublicAccess(Guid id)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionProtect.ActionLetter, id),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<PublicAccessEntry?, PublicAccessOperationStatus> accessAttempt =
+            await _publicAccessService.GetEntryByContentKeyAsync(id);
+
+        if (accessAttempt.Success is false)
+        {
+            return PublicAccessOperationStatusResult(accessAttempt.Status);
+        }
+
+        if (accessAttempt.Result is null)
+        {
+            return Ok();
+        }
+
+        Attempt<PublicAccessResponseModel?, PublicAccessOperationStatus> responseModelAttempt =
+            _publicAccessPresentationFactory.CreatePublicAccessResponseModel(accessAttempt.Result);
+
+        if (responseModelAttempt.Success is false)
+        {
+            return PublicAccessOperationStatusResult(responseModelAttempt.Status);
+        }
+
+        return Ok(responseModelAttempt.Result);
+    }
+}
@@ -0,0 +1,15 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.Item;
+
+[ApiController]
+[VersionedApiBackOfficeRoute($"{Constants.Web.RoutePath.Item}/{Constants.UdiEntityType.Document}")]
+[ApiExplorerSettings(GroupName = nameof(Constants.UdiEntityType.Document))]
+[Authorize(Policy = "New" + AuthorizationPolicies.TreeAccessDocuments)]
+public class DocumentItemControllerBase : ManagementApiControllerBase
+{
+}
@@ -0,0 +1,36 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Document.Item;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.Item;
+
+[ApiVersion("1.0")]
+public class ItemDocumentItemController : DocumentItemControllerBase
+{
+    private readonly IEntityService _entityService;
+    private readonly IDocumentPresentationFactory _documentPresentationFactory;
+
+    public ItemDocumentItemController(IEntityService entityService, IDocumentPresentationFactory documentPresentationFactory)
+    {
+        _entityService = entityService;
+        _documentPresentationFactory = documentPresentationFactory;
+    }
+
+    [HttpGet]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(IEnumerable<DocumentItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult> Item([FromQuery(Name = "id")] HashSet<Guid> ids)
+    {
+        IEnumerable<IDocumentEntitySlim> documents = _entityService
+            .GetAll(UmbracoObjectTypes.Document, ids.ToArray())
+            .OfType<IDocumentEntitySlim>();
+
+        IEnumerable<DocumentItemResponseModel> documentItemResponseModels = documents.Select(_documentPresentationFactory.CreateItemResponseModel);
+        return await Task.FromResult(Ok(documentItemResponseModels));
+    }
+}
@@ -0,0 +1,60 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class MoveDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentEditingService _contentEditingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public MoveDocumentController(
+        IAuthorizationService authorizationService,
+        IContentEditingService contentEditingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _authorizationService = authorizationService;
+        _contentEditingService = contentEditingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPut("{id:guid}/move")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Move(Guid id, MoveDocumentRequestModel moveDocumentRequestModel)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionMove.ActionLetter, new[] { moveDocumentRequestModel.Target?.Id, id }),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<IContent?, ContentEditingOperationStatus> result = await _contentEditingService.MoveAsync(
+            id,
+            moveDocumentRequestModel.Target?.Id,
+            CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? Ok()
+            : ContentEditingOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,56 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class MoveToRecycleBinDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentEditingService _contentEditingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public MoveToRecycleBinDocumentController(
+        IAuthorizationService authorizationService,
+        IContentEditingService contentEditingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _authorizationService = authorizationService;
+        _contentEditingService = contentEditingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPut("{id:guid}/move-to-recycle-bin")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> MoveToRecycleBin(Guid id)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionDelete.ActionLetter, id),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<IContent?, ContentEditingOperationStatus> result = await _contentEditingService.MoveToRecycleBinAsync(id, CurrentUserKey(_backOfficeSecurityAccessor));
+        return result.Success
+            ? Ok()
+            : ContentEditingOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,54 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class NotificationsController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentEditingService _contentEditingService;
+    private readonly IDocumentNotificationPresentationFactory _documentNotificationPresentationFactory;
+
+    public NotificationsController(
+        IAuthorizationService authorizationService,
+        IContentEditingService contentEditingService,
+        IDocumentNotificationPresentationFactory documentNotificationPresentationFactory)
+    {
+        _authorizationService = authorizationService;
+        _contentEditingService = contentEditingService;
+        _documentNotificationPresentationFactory = documentNotificationPresentationFactory;
+    }
+
+    [MapToApiVersion("1.0")]
+    [HttpGet("{id:guid}/notifications")]
+    [ProducesResponseType(typeof(IEnumerable<DocumentNotificationResponseModel>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Notifications(Guid id)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionBrowse.ActionLetter, id),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        IContent? content = await _contentEditingService.GetAsync(id);
+        return content != null
+            ? Ok(await _documentNotificationPresentationFactory.CreateNotificationModelsAsync(content))
+            : DocumentNotFound();
+    }
+}
@@ -0,0 +1,61 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.Security.Authorization.UserGroup;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models.ContentPublishing;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class PublishDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentPublishingService _contentPublishingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public PublishDocumentController(
+        IAuthorizationService authorizationService,
+        IContentPublishingService contentPublishingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _authorizationService = authorizationService;
+        _contentPublishingService = contentPublishingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPut("{id:guid}/publish")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Publish(Guid id, PublishDocumentRequestModel requestModel)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionPublish.ActionLetter, id, requestModel.Cultures),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<ContentPublishingResult, ContentPublishingOperationStatus> attempt = await _contentPublishingService.PublishAsync(
+            id,
+            requestModel.Cultures,
+            CurrentUserKey(_backOfficeSecurityAccessor));
+        return attempt.Success
+            ? Ok()
+            : DocumentPublishingOperationStatusResult(attempt.Status, invalidPropertyAliases: attempt.Result.InvalidPropertyAliases);
+    }
+}
@@ -0,0 +1,62 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models.ContentPublishing;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class PublishDocumentWithDescendantsController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentPublishingService _contentPublishingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public PublishDocumentWithDescendantsController(
+        IAuthorizationService authorizationService,
+        IContentPublishingService contentPublishingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _authorizationService = authorizationService;
+        _contentPublishingService = contentPublishingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPut("{id:guid}/publish-with-descendants")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> PublishWithDescendants(Guid id, PublishDocumentWithDescendantsRequestModel requestModel)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.Branch(ActionPublish.ActionLetter, id, requestModel.Cultures),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<ContentPublishingBranchResult, ContentPublishingOperationStatus> attempt = await _contentPublishingService.PublishBranchAsync(
+            id,
+            requestModel.Cultures,
+            requestModel.IncludeUnpublishedDescendants,
+            CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return attempt.Success
+            ? Ok()
+            : DocumentPublishingOperationStatusResult(attempt.Status, failedBranchItems: attempt.Result.FailedItems);
+    }
+}
@@ -0,0 +1,24 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Document.RecycleBin;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.RecycleBin;
+
+[ApiVersion("1.0")]
+public class ChildrenDocumentRecycleBinController : DocumentRecycleBinControllerBase
+{
+    public ChildrenDocumentRecycleBinController(IEntityService entityService, IDocumentPresentationFactory documentPresentationFactory)
+        : base(entityService, documentPresentationFactory)
+    {
+    }
+
+    [HttpGet("children")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<DocumentRecycleBinItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedViewModel<DocumentRecycleBinItemResponseModel>>> Children(Guid parentId, int skip = 0, int take = 100)
+        => await GetChildren(parentId, skip, take);
+}
@@ -0,0 +1,61 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.RecycleBin;
+
+[ApiVersion("1.0")]
+public class DeleteDocumentRecycleBinController : DocumentRecycleBinControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+    private readonly IContentEditingService _contentEditingService;
+
+    public DeleteDocumentRecycleBinController(
+        IEntityService entityService,
+        IDocumentPresentationFactory documentPresentationFactory,
+        IAuthorizationService authorizationService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
+        IContentEditingService contentEditingService)
+        : base(entityService, documentPresentationFactory)
+    {
+        _authorizationService = authorizationService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+        _contentEditingService = contentEditingService;
+    }
+
+    [HttpDelete("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Delete(Guid id)
+    {
+        AuthorizationResult authorizationResult  = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.RecycleBin(ActionDelete.ActionLetter),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<IContent?, ContentEditingOperationStatus> result = await _contentEditingService.DeleteFromRecycleBinAsync(id, CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result.Success
+            ? Ok()
+            : ContentEditingOperationStatusResult(result.Status);
+    }
+}
@@ -0,0 +1,45 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.Controllers.RecycleBin;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.Filters;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Api.Management.ViewModels.Document.RecycleBin;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.RecycleBin;
+
+[ApiController]
+[VersionedApiBackOfficeRoute($"{Constants.Web.RoutePath.RecycleBin}/{Constants.UdiEntityType.Document}")]
+[RequireDocumentTreeRootAccess]
+[ApiExplorerSettings(GroupName = nameof(Constants.UdiEntityType.Document))]
+[Authorize(Policy = "New" + AuthorizationPolicies.TreeAccessDocuments)]
+public class DocumentRecycleBinControllerBase : RecycleBinControllerBase<DocumentRecycleBinItemResponseModel>
+{
+    private readonly IDocumentPresentationFactory _documentPresentationFactory;
+
+    public DocumentRecycleBinControllerBase(IEntityService entityService, IDocumentPresentationFactory documentPresentationFactory)
+        : base(entityService)
+        => _documentPresentationFactory = documentPresentationFactory;
+
+    protected override UmbracoObjectTypes ItemObjectType => UmbracoObjectTypes.Document;
+
+    protected override int RecycleBinRootId => Constants.System.RecycleBinContent;
+
+    protected override DocumentRecycleBinItemResponseModel MapRecycleBinViewModel(Guid? parentId, IEntitySlim entity)
+    {
+        DocumentRecycleBinItemResponseModel responseModel = base.MapRecycleBinViewModel(parentId, entity);
+
+        if (entity is IDocumentEntitySlim documentEntitySlim)
+        {
+            responseModel.Variants = _documentPresentationFactory.CreateVariantsItemResponseModels(documentEntitySlim);
+            responseModel.DocumentType = _documentPresentationFactory.CreateDocumentTypeReferenceResponseModel(documentEntitySlim);
+        }
+
+        return responseModel;
+    }
+}
@@ -0,0 +1,56 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.RecycleBin;
+
+[ApiVersion("1.0")]
+public class EmptyDocumentRecycleBinController : DocumentRecycleBinControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+    private readonly IContentService _contentService;
+
+    public EmptyDocumentRecycleBinController(
+        IEntityService entityService,
+        IAuthorizationService authorizationService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor,
+        IContentService contentService,
+        IDocumentPresentationFactory documentPresentationFactory)
+        : base(entityService, documentPresentationFactory)
+    {
+        _authorizationService = authorizationService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+        _contentService = contentService;
+    }
+
+    [HttpDelete]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    public async Task<IActionResult> EmptyRecycleBin()
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.RecycleBin(ActionDelete.ActionLetter),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (authorizationResult.Succeeded is false)
+        {
+            return Forbidden();
+        }
+
+        OperationResult result = await _contentService.EmptyRecycleBinAsync(CurrentUserKey(_backOfficeSecurityAccessor));
+        return result.Success
+            ? Ok()
+            : OperationStatusResult(result);
+    }
+}
@@ -0,0 +1,24 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Document.RecycleBin;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.RecycleBin;
+
+[ApiVersion("1.0")]
+public class RootDocumentRecycleBinController : DocumentRecycleBinControllerBase
+{
+    public RootDocumentRecycleBinController(IEntityService entityService, IDocumentPresentationFactory documentPresentationFactory)
+        : base(entityService, documentPresentationFactory)
+    {
+    }
+
+    [HttpGet("root")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<DocumentRecycleBinItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedViewModel<DocumentRecycleBinItemResponseModel>>> Root(int skip = 0, int take = 100)
+        => await GetRoot(skip, take);
+}
@@ -0,0 +1,60 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Sorting;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models.ContentEditing;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class SortDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentEditingService _contentEditingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public SortDocumentController(
+        IAuthorizationService authorizationService,
+        IContentEditingService contentEditingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _authorizationService = authorizationService;
+        _contentEditingService = contentEditingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPut("sort")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Sort(SortingRequestModel sortingRequestModel)
+    {
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionSort.ActionLetter,  new List<Guid?>(sortingRequestModel.Sorting.Select(x => x.Id).Cast<Guid?>()) { sortingRequestModel.Parent?.Id }),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        ContentEditingOperationStatus result = await _contentEditingService.SortAsync(
+            sortingRequestModel.Parent?.Id,
+            sortingRequestModel.Sorting.Select(m => new SortingModel { Key = m.Id, SortOrder = m.SortOrder }),
+            CurrentUserKey(_backOfficeSecurityAccessor));
+
+        return result == ContentEditingOperationStatus.Success
+            ? Ok()
+            : ContentEditingOperationStatusResult(result);
+    }
+}
@@ -0,0 +1,44 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Cache;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.Services.Entities;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.Tree;
+
+[ApiVersion("1.0")]
+public class ChildrenDocumentTreeController : DocumentTreeControllerBase
+{
+    public ChildrenDocumentTreeController(
+        IEntityService entityService,
+        IUserStartNodeEntitiesService userStartNodeEntitiesService,
+        IDataTypeService dataTypeService,
+        IPublicAccessService publicAccessService,
+        AppCaches appCaches,
+        IBackOfficeSecurityAccessor backofficeSecurityAccessor,
+        IDocumentPresentationFactory documentPresentationFactory)
+        : base(
+            entityService,
+            userStartNodeEntitiesService,
+            dataTypeService,
+            publicAccessService,
+            appCaches,
+            backofficeSecurityAccessor,
+            documentPresentationFactory)
+    {
+    }
+
+    [HttpGet("children")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<DocumentTreeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedViewModel<DocumentTreeItemResponseModel>>> Children(Guid parentId, int skip = 0, int take = 100, Guid? dataTypeId = null)
+    {
+        IgnoreUserStartNodesForDataType(dataTypeId);
+        return await GetChildren(parentId, skip, take);
+    }
+}
@@ -0,0 +1,85 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Cache;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.Controllers.Tree;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.Services.Entities;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+using Umbraco.Cms.Api.Management.Routing;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.Tree;
+
+[ApiController]
+[VersionedApiBackOfficeRoute($"{Constants.Web.RoutePath.Tree}/{Constants.UdiEntityType.Document}")]
+[ApiExplorerSettings(GroupName = nameof(Constants.UdiEntityType.Document))]
+[Authorize(Policy = "New" + AuthorizationPolicies.SectionAccessForContentTree)]
+public abstract class DocumentTreeControllerBase : UserStartNodeTreeControllerBase<DocumentTreeItemResponseModel>
+{
+    private readonly IPublicAccessService _publicAccessService;
+    private readonly AppCaches _appCaches;
+    private readonly IBackOfficeSecurityAccessor _backofficeSecurityAccessor;
+    private readonly IDocumentPresentationFactory _documentPresentationFactory;
+
+    protected DocumentTreeControllerBase(
+        IEntityService entityService,
+        IUserStartNodeEntitiesService userStartNodeEntitiesService,
+        IDataTypeService dataTypeService,
+        IPublicAccessService publicAccessService,
+        AppCaches appCaches,
+        IBackOfficeSecurityAccessor backofficeSecurityAccessor,
+        IDocumentPresentationFactory documentPresentationFactory)
+        : base(entityService, userStartNodeEntitiesService, dataTypeService)
+    {
+        _publicAccessService = publicAccessService;
+        _appCaches = appCaches;
+        _backofficeSecurityAccessor = backofficeSecurityAccessor;
+        _documentPresentationFactory = documentPresentationFactory;
+    }
+
+    protected override UmbracoObjectTypes ItemObjectType => UmbracoObjectTypes.Document;
+
+    protected override Ordering ItemOrdering => Ordering.By(nameof(Infrastructure.Persistence.Dtos.NodeDto.SortOrder));
+
+    protected override DocumentTreeItemResponseModel MapTreeItemViewModel(Guid? parentId, IEntitySlim entity)
+    {
+        DocumentTreeItemResponseModel responseModel = base.MapTreeItemViewModel(parentId, entity);
+
+        if (entity is IDocumentEntitySlim documentEntitySlim)
+        {
+            responseModel.IsProtected = _publicAccessService.IsProtected(entity.Path);
+            responseModel.IsTrashed = entity.Trashed;
+            responseModel.Id = entity.Key;
+
+            responseModel.Variants = _documentPresentationFactory.CreateVariantsItemResponseModels(documentEntitySlim);
+            responseModel.DocumentType = _documentPresentationFactory.CreateDocumentTypeReferenceResponseModel(documentEntitySlim);
+        }
+
+        return responseModel;
+    }
+
+    // TODO: delete these (faking start node setup for unlimited editor)
+    protected override int[] GetUserStartNodeIds() => new[] { -1 };
+
+    protected override string[] GetUserStartNodePaths() => Array.Empty<string>();
+
+    // TODO: use these implementations instead of the dummy ones above once we have backoffice auth in place
+    // protected override int[] GetUserStartNodeIds()
+    //     => _backofficeSecurityAccessor
+    //            .BackOfficeSecurity?
+    //            .CurrentUser?
+    //            .CalculateContentStartNodeIds(EntityService, _appCaches)
+    //        ?? Array.Empty<int>();
+    //
+    // protected override string[] GetUserStartNodePaths()
+    //     => _backofficeSecurityAccessor
+    //            .BackOfficeSecurity?
+    //            .CurrentUser?
+    //            .GetContentStartNodePaths(EntityService, _appCaches)
+    //        ?? Array.Empty<string>();
+}
@@ -0,0 +1,44 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core.Cache;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Api.Management.Services.Entities;
+using Umbraco.Cms.Api.Common.ViewModels.Pagination;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Tree;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document.Tree;
+
+[ApiVersion("1.0")]
+public class RootDocumentTreeController : DocumentTreeControllerBase
+{
+    public RootDocumentTreeController(
+        IEntityService entityService,
+        IUserStartNodeEntitiesService userStartNodeEntitiesService,
+        IDataTypeService dataTypeService,
+        IPublicAccessService publicAccessService,
+        AppCaches appCaches,
+        IBackOfficeSecurityAccessor backofficeSecurityAccessor,
+        IDocumentPresentationFactory documentPresentationFactory)
+        : base(
+            entityService,
+            userStartNodeEntitiesService,
+            dataTypeService,
+            publicAccessService,
+            appCaches,
+            backofficeSecurityAccessor,
+            documentPresentationFactory)
+    {
+    }
+
+    [HttpGet("root")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(typeof(PagedViewModel<DocumentTreeItemResponseModel>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedViewModel<DocumentTreeItemResponseModel>>> Root(int skip = 0, int take = 100, Guid? dataTypeId = null)
+    {
+        IgnoreUserStartNodesForDataType(dataTypeId);
+        return await GetRoot(skip, take);
+    }
+}
@@ -0,0 +1,63 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class UnpublishDocumentController : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentPublishingService _contentPublishingService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public UnpublishDocumentController(
+        IAuthorizationService authorizationService,
+        IContentPublishingService contentPublishingService,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _authorizationService = authorizationService;
+        _contentPublishingService = contentPublishingService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPut("{id:guid}/unpublish")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Unpublish(Guid id, UnpublishDocumentRequestModel requestModel)
+    {
+
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(
+                ActionUnpublish.ActionLetter,
+                id,
+                requestModel.Culture is not null ? requestModel.Culture.Yield() : Enumerable.Empty<string>()),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        Attempt<ContentPublishingOperationStatus> attempt = await _contentPublishingService.UnpublishAsync(
+            id,
+            requestModel.Culture,
+            CurrentUserKey(_backOfficeSecurityAccessor));
+        return attempt.Success
+            ? Ok()
+            : DocumentPublishingOperationStatusResult(attempt.Result);
+    }
+}
@@ -0,0 +1,50 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Factories;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models.ContentEditing;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class UpdateDocumentController : UpdateDocumentControllerBase
+{
+    private readonly IContentEditingService _contentEditingService;
+    private readonly IDocumentEditingPresentationFactory _documentEditingPresentationFactory;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public UpdateDocumentController(
+        IAuthorizationService authorizationService,
+        IContentEditingService contentEditingService,
+        IDocumentEditingPresentationFactory documentEditingPresentationFactory,
+        IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+        : base(authorizationService, contentEditingService)
+    {
+        _contentEditingService = contentEditingService;
+        _documentEditingPresentationFactory = documentEditingPresentationFactory;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [HttpPut("{id:guid}")]
+    [MapToApiVersion("1.0")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> Update(Guid id, UpdateDocumentRequestModel requestModel)
+        => await HandleRequest(id, requestModel, async content =>
+        {
+            ContentUpdateModel model = _documentEditingPresentationFactory.MapUpdateModel(requestModel);
+            Attempt<ContentUpdateResult, ContentEditingOperationStatus> result =
+                await _contentEditingService.UpdateAsync(content, model, CurrentUserKey(_backOfficeSecurityAccessor));
+
+            return result.Success
+                ? Ok()
+                : ContentEditingOperationStatusResult(result.Status);
+        });
+}
@@ -0,0 +1,47 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.Security.Authorization.Content;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core.Actions;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Web.Common.Authorization;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+public abstract class UpdateDocumentControllerBase : DocumentControllerBase
+{
+    private readonly IAuthorizationService _authorizationService;
+    private readonly IContentEditingService _contentEditingService;
+
+    protected UpdateDocumentControllerBase(IAuthorizationService authorizationService, IContentEditingService contentEditingService)
+    {
+        _authorizationService = authorizationService;
+        _contentEditingService = contentEditingService;
+    }
+
+    protected async Task<IActionResult> HandleRequest(Guid id, UpdateDocumentRequestModel requestModel, Func<IContent, Task<IActionResult>> authorizedHandler)
+    {
+        IEnumerable<string> cultures = requestModel.Variants
+            .Where(v => v.Culture is not null)
+            .Select(v => v.Culture!);
+        AuthorizationResult authorizationResult = await _authorizationService.AuthorizeResourceAsync(
+            User,
+            ContentPermissionResource.WithKeys(ActionUpdate.ActionLetter, id, cultures),
+            AuthorizationPolicies.ContentPermissionByResource);
+
+        if (!authorizationResult.Succeeded)
+        {
+            return Forbidden();
+        }
+
+        IContent? content = await _contentEditingService.GetAsync(id);
+        if (content is null)
+        {
+            return DocumentNotFound();
+        }
+
+        return await authorizedHandler(content);
+    }
+}
@@ -0,0 +1,58 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Common.Builders;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Mapping;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.ContentEditing;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Core.Services.OperationStatus;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class UpdateDomainsController : DocumentControllerBase
+{
+    private readonly IDomainService _domainService;
+    private readonly IUmbracoMapper _umbracoMapper;
+
+    public UpdateDomainsController(IDomainService domainService, IUmbracoMapper umbracoMapper)
+    {
+        _domainService = domainService;
+        _umbracoMapper = umbracoMapper;
+    }
+
+    [MapToApiVersion("1.0")]
+    [HttpPut("{id:guid}/domains")]
+    public async Task<IActionResult> Update(Guid id, UpdateDomainsRequestModel updateModel)
+    {
+        DomainsUpdateModel domainsUpdateModel = _umbracoMapper.Map<DomainsUpdateModel>(updateModel)!;
+
+        Attempt<IEnumerable<IDomain>, DomainOperationStatus> result = await _domainService.UpdateDomainsAsync(id, domainsUpdateModel);
+
+        return result.Status switch
+        {
+            DomainOperationStatus.Success => Ok(),
+            DomainOperationStatus.CancelledByNotification => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("Cancelled by notification")
+                .WithDetail("A notification handler prevented the domain update operation.")
+                .Build()),
+            DomainOperationStatus.ContentNotFound => NotFound(new ProblemDetailsBuilder()
+                    .WithTitle("The targeted content item was not found.")
+                    .Build()),
+            DomainOperationStatus.LanguageNotFound => BadRequest(new ProblemDetailsBuilder()
+                .WithTitle("Invalid language specified")
+                .WithDetail("One or more of the specified language ISO codes could not be found.")
+                .Build()),
+            DomainOperationStatus.DuplicateDomainName => Conflict(new ProblemDetailsBuilder()
+                .WithTitle("Duplicate domain name detected")
+                .WithDetail("One or more of the specified domain names were duplicates, possibly of assignments to other content items.")
+                .Build()),
+            _ => StatusCode(StatusCodes.Status500InternalServerError, new ProblemDetailsBuilder()
+                .WithTitle("Unknown domain update operation status.")
+                .Build()),
+        };
+    }
+}
@@ -0,0 +1,40 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Security;
+using Umbraco.Cms.Core.Services;
+
+namespace Umbraco.Cms.Api.Management.Controllers.Document;
+
+[ApiVersion("1.0")]
+public class UpdateNotificationsController : DocumentControllerBase
+{
+    private readonly IContentEditingService _contentEditingService;
+    private readonly INotificationService _notificationService;
+    private readonly IBackOfficeSecurityAccessor _backOfficeSecurityAccessor;
+
+    public UpdateNotificationsController(IContentEditingService contentEditingService, INotificationService notificationService, IBackOfficeSecurityAccessor backOfficeSecurityAccessor)
+    {
+        _contentEditingService = contentEditingService;
+        _notificationService = notificationService;
+        _backOfficeSecurityAccessor = backOfficeSecurityAccessor;
+    }
+
+    [MapToApiVersion("1.0")]
+    [HttpPut("{id:guid}/notifications")]
+    [ProducesResponseType(StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> UpdateNotifications(Guid id, UpdateDocumentNotificationsRequestModel updateModel)
+    {
+        IContent? content = await _contentEditingService.GetAsync(id);
+        if (content == null)
+        {
+            return DocumentNotFound();
+        }
+
+        _notificationService.SetNotifications(_backOfficeSecurityAccessor.BackOfficeSecurity?.CurrentUser, content, updateModel.SubscribedActionIds);
+        return await Task.FromResult(Ok());
+    }
+}
--- a/Show More
+++ b/Show More