diff --git a/src/Umbraco.Core/Configuration/Models/ContentSettings.cs b/src/Umbraco.Core/Configuration/Models/ContentSettings.cs
index 93a97355d9b4..e6e5c7006fe7 100644
--- a/src/Umbraco.Core/Configuration/Models/ContentSettings.cs
+++ b/src/Umbraco.Core/Configuration/Models/ContentSettings.cs
@@ -157,6 +157,8 @@ @keyframes umbraco-preview-badge--effect {{
         internal const string StaticLoginBackgroundImage = "assets/img/login.jpg";
         internal const string StaticLoginLogoImage = "assets/img/application/umbraco_logo_white.svg";
         internal const bool StaticHideBackOfficeLogo = false;
+        internal const bool StaticDisableDeleteWhenReferenced = false;
+        internal const bool StaticDisableUnpublishWhenReferenced = false;
 
         /// <summary>
         /// Gets or sets a value for the content notification settings.
@@ -226,6 +228,18 @@ @keyframes umbraco-preview-badge--effect {{
         [DefaultValue(StaticHideBackOfficeLogo)]
         public bool HideBackOfficeLogo { get; set; } = StaticHideBackOfficeLogo;
 
+        /// <summary>
+        /// Gets or sets a value indicating whether to disable the deletion of items referenced by other items.
+        /// </summary>
+        [DefaultValue(StaticDisableDeleteWhenReferenced)]
+        public bool DisableDeleteWhenReferenced { get; set; } = StaticDisableDeleteWhenReferenced;
+
+        /// <summary>
+        /// Gets or sets a value indicating whether to disable the unpublishing of items referenced by other items.
+        /// </summary>
+        [DefaultValue(StaticDisableUnpublishWhenReferenced)]
+        public bool DisableUnpublishWhenReferenced { get; set; } = StaticDisableUnpublishWhenReferenced;
+
         /// <summary>
         /// Get or sets the model representing the global content version cleanup policy
         /// </summary>
diff --git a/src/Umbraco.Core/Events/RelateOnCopyNotificationHandler.cs b/src/Umbraco.Core/Events/RelateOnCopyNotificationHandler.cs
index 0a6518a1ca05..3a73173127c4 100644
--- a/src/Umbraco.Core/Events/RelateOnCopyNotificationHandler.cs
+++ b/src/Umbraco.Core/Events/RelateOnCopyNotificationHandler.cs
@@ -33,7 +33,8 @@ public void Handle(ContentCopiedNotification notification)
                     Constants.Conventions.RelationTypes.RelateDocumentOnCopyName,
                     true,
                     Constants.ObjectTypes.Document,
-                    Constants.ObjectTypes.Document);
+                    Constants.ObjectTypes.Document,
+                    false);
 
                 _relationService.Save(relationType);
             }
diff --git a/src/Umbraco.Core/Models/ContentEditing/RelationTypeDisplay.cs b/src/Umbraco.Core/Models/ContentEditing/RelationTypeDisplay.cs
index 27f0f525df72..6a4c8e5f81a5 100644
--- a/src/Umbraco.Core/Models/ContentEditing/RelationTypeDisplay.cs
+++ b/src/Umbraco.Core/Models/ContentEditing/RelationTypeDisplay.cs
@@ -55,5 +55,11 @@ public RelationTypeDisplay()
         /// </summary>
         [DataMember(Name = "notifications")]
         public List<BackOfficeNotification> Notifications { get; private set; }
+
+        /// <summary>
+        /// Gets or sets a boolean indicating whether the RelationType should be returned in "Used by"-queries.
+        /// </summary>
+        [DataMember(Name = "isDependency", IsRequired = true)]
+        public bool IsDependency { get; set; }
     }
 }
diff --git a/src/Umbraco.Core/Models/ContentEditing/RelationTypeSave.cs b/src/Umbraco.Core/Models/ContentEditing/RelationTypeSave.cs
index b72a03eec4a4..f541158095d9 100644
--- a/src/Umbraco.Core/Models/ContentEditing/RelationTypeSave.cs
+++ b/src/Umbraco.Core/Models/ContentEditing/RelationTypeSave.cs
@@ -23,5 +23,11 @@ public class RelationTypeSave : EntityBasic
         /// </summary>
         [DataMember(Name = "childObjectType", IsRequired = false)]
         public Guid? ChildObjectType { get; set; }
+
+        /// <summary>
+        /// Gets or sets a boolean indicating whether the RelationType should be returned in "Used by"-queries.
+        /// </summary>
+        [DataMember(Name = "isDependency", IsRequired = true)]
+        public bool IsDependency { get; set; }
     }
 }
diff --git a/src/Umbraco.Core/Models/IRelationType.cs b/src/Umbraco.Core/Models/IRelationType.cs
index 9efde4b93901..3ee1517f557e 100644
--- a/src/Umbraco.Core/Models/IRelationType.cs
+++ b/src/Umbraco.Core/Models/IRelationType.cs
@@ -4,6 +4,15 @@
 
 namespace Umbraco.Cms.Core.Models
 {
+    public interface IRelationTypeWithIsDependency : IRelationType
+    {
+        /// <summary>
+        /// Gets or sets a boolean indicating whether the RelationType should be returned in "Used by"-queries.
+        /// </summary>
+        [DataMember]
+        bool IsDependency { get; set; }
+    }
+
     public interface IRelationType : IEntity, IRememberBeingDirty
     {
         /// <summary>
diff --git a/src/Umbraco.Core/Models/Mapping/RelationMapDefinition.cs b/src/Umbraco.Core/Models/Mapping/RelationMapDefinition.cs
index 41caa526e20d..2b333652b938 100644
--- a/src/Umbraco.Core/Models/Mapping/RelationMapDefinition.cs
+++ b/src/Umbraco.Core/Models/Mapping/RelationMapDefinition.cs
@@ -30,6 +30,11 @@ private void Map(IRelationType source, RelationTypeDisplay target, MapperContext
             target.ChildObjectType = source.ChildObjectType;
             target.Id = source.Id;
             target.IsBidirectional = source.IsBidirectional;
+
+            if (source is IRelationTypeWithIsDependency sourceWithIsDependency)
+            {
+                target.IsDependency = sourceWithIsDependency.IsDependency;
+            }
             target.Key = source.Key;
             target.Name = source.Name;
             target.Alias = source.Alias;
@@ -74,6 +79,11 @@ private static void Map(RelationTypeSave source, IRelationType target, MapperCon
             target.ChildObjectType = source.ChildObjectType;
             target.Id = source.Id.TryConvertTo<int>().Result;
             target.IsBidirectional = source.IsBidirectional;
+            if (target is IRelationTypeWithIsDependency targetWithIsDependency)
+            {
+                targetWithIsDependency.IsDependency = source.IsDependency;
+            }
+
             target.Key = source.Key;
             target.Name = source.Name;
             target.ParentObjectType = source.ParentObjectType;
diff --git a/src/Umbraco.Core/Models/RelationItem.cs b/src/Umbraco.Core/Models/RelationItem.cs
new file mode 100644
index 000000000000..cebbc2095101
--- /dev/null
+++ b/src/Umbraco.Core/Models/RelationItem.cs
@@ -0,0 +1,44 @@
+using System;
+using System.Runtime.Serialization;
+using Umbraco.Cms.Core.Models.Entities;
+
+namespace Umbraco.Cms.Core.Models
+{
+    [DataContract(Name = "relationItem", Namespace = "")]
+    public class RelationItem
+    {
+        [DataMember(Name = "id")]
+        public int NodeId { get; set; }
+
+        [DataMember(Name = "key")]
+        public Guid NodeKey { get; set; }
+
+        [DataMember(Name = "name")]
+        public string NodeName { get; set; }
+
+        [DataMember(Name = "type")]
+        public string NodeType { get; set; }
+
+        [DataMember(Name = "udi")]
+        public Udi NodeUdi => Udi.Create(NodeType, NodeKey);
+
+        [DataMember(Name = "icon")]
+        public string ContentTypeIcon { get; set; }
+
+        [DataMember(Name = "alias")]
+        public string ContentTypeAlias { get; set; }
+
+        [DataMember(Name = "contentTypeName")]
+        public string ContentTypeName { get; set; }
+
+        [DataMember(Name = "relationTypeName")]
+        public string RelationTypeName { get; set; }
+
+        [DataMember(Name = "relationTypeIsBidirectional")]
+        public bool RelationTypeIsBidirectional { get; set; }
+
+        [DataMember(Name = "relationTypeIsDependency")]
+        public bool RelationTypeIsDependency { get; set; }
+
+    }
+}
diff --git a/src/Umbraco.Core/Models/RelationType.cs b/src/Umbraco.Core/Models/RelationType.cs
index 2def0eb6366f..5de0aaac8fd8 100644
--- a/src/Umbraco.Core/Models/RelationType.cs
+++ b/src/Umbraco.Core/Models/RelationType.cs
@@ -9,20 +9,28 @@ namespace Umbraco.Cms.Core.Models
     /// </summary>
     [Serializable]
     [DataContract(IsReference = true)]
-    public class RelationType : EntityBase, IRelationType
+    public class RelationType : EntityBase, IRelationType, IRelationTypeWithIsDependency
     {
         private string _name;
         private string _alias;
         private bool _isBidirectional;
+        private bool _isDependency;
         private Guid? _parentObjectType;
         private Guid? _childObjectType;
 
         public RelationType(string alias, string name)
-            : this(name: name, alias: alias, false, null, null)
+            : this(name: name, alias: alias, false, null, null, false)
         {
         }
 
+        [Obsolete("Use ctor with isDependency parameter")]
         public RelationType(string name, string alias, bool isBidrectional, Guid? parentObjectType, Guid? childObjectType)
+        :this(name,alias,isBidrectional, parentObjectType, childObjectType, false)
+        {
+
+        }
+
+        public RelationType(string name, string alias, bool isBidrectional, Guid? parentObjectType, Guid? childObjectType, bool isDependency)
         {
             if (name == null) throw new ArgumentNullException(nameof(name));
             if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
@@ -32,6 +40,7 @@ public RelationType(string name, string alias, bool isBidrectional, Guid? parent
             _name = name;
             _alias = alias;
             _isBidirectional = isBidrectional;
+            _isDependency = isDependency;
             _parentObjectType = parentObjectType;
             _childObjectType = childObjectType;
         }
@@ -88,5 +97,11 @@ public Guid? ChildObjectType
             set => SetPropertyValueAndDetectChanges(value, ref _childObjectType, nameof(ChildObjectType));
         }
 
+
+        public bool IsDependency
+        {
+            get => _isDependency;
+            set => SetPropertyValueAndDetectChanges(value, ref _isDependency, nameof(IsDependency));
+        }
     }
 }
diff --git a/src/Umbraco.Core/Persistence/Repositories/IRelationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/IRelationRepository.cs
index cff64d4a7947..c863ef4d8e6d 100644
--- a/src/Umbraco.Core/Persistence/Repositories/IRelationRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/IRelationRepository.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Entities;
diff --git a/src/Umbraco.Core/Persistence/Repositories/ITrackedReferencesRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ITrackedReferencesRepository.cs
new file mode 100644
index 000000000000..42746a956535
--- /dev/null
+++ b/src/Umbraco.Core/Persistence/Repositories/ITrackedReferencesRepository.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.Entities;
+
+namespace Umbraco.Cms.Core.Persistence.Repositories
+{
+    public interface ITrackedReferencesRepository
+    {
+        IEnumerable<RelationItem> GetPagedRelationsForItems(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency,out long totalRecords);
+        IEnumerable<RelationItem> GetPagedItemsWithRelations(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency,out long totalRecords);
+        IEnumerable<RelationItem> GetPagedDescendantsInReferences(int parentId, long pageIndex, int pageSize, bool filterMustBeIsDependency,out long totalRecords);
+    }
+}
diff --git a/src/Umbraco.Core/Services/IRelationService.cs b/src/Umbraco.Core/Services/IRelationService.cs
index ce00f774f8bd..4d0e977d3895 100644
--- a/src/Umbraco.Core/Services/IRelationService.cs
+++ b/src/Umbraco.Core/Services/IRelationService.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Entities;
@@ -215,7 +215,7 @@ public interface IRelationService : IService
         /// <param name="pageIndex"></param>
         /// <param name="pageSize"></param>
         /// <param name="totalChildren"></param>
-        /// <returns></returns>
+        /// <returns>An enumerable list of <see cref="IUmbracoEntity"/></returns>
         IEnumerable<IUmbracoEntity> GetPagedParentEntitiesByChildId(int id, long pageIndex, int pageSize, out long totalChildren, params UmbracoObjectTypes[] entityTypes);
 
         /// <summary>
@@ -225,7 +225,7 @@ public interface IRelationService : IService
         /// <param name="pageIndex"></param>
         /// <param name="pageSize"></param>
         /// <param name="totalChildren"></param>
-        /// <returns></returns>
+        /// <returns>An enumerable list of <see cref="IUmbracoEntity"/></returns>
         IEnumerable<IUmbracoEntity> GetPagedChildEntitiesByParentId(int id, long pageIndex, int pageSize, out long totalChildren, params UmbracoObjectTypes[] entityTypes);
 
         /// <summary>
diff --git a/src/Umbraco.Core/Services/ITrackedReferencesService.cs b/src/Umbraco.Core/Services/ITrackedReferencesService.cs
new file mode 100644
index 000000000000..eee8a324dfe2
--- /dev/null
+++ b/src/Umbraco.Core/Services/ITrackedReferencesService.cs
@@ -0,0 +1,15 @@
+using Umbraco.Cms.Core.Models;
+
+namespace Umbraco.Cms.Core.Services
+{
+    public interface ITrackedReferencesService
+    {
+        PagedResult<RelationItem> GetPagedRelationsForItems(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency);
+
+
+        PagedResult<RelationItem> GetPagedDescendantsInReferences(int parentId, long pageIndex, int pageSize, bool filterMustBeIsDependency);
+
+
+        PagedResult<RelationItem> GetPagedItemsWithRelations(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency);
+    }
+}
diff --git a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Repositories.cs b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Repositories.cs
index f9dc43cbd5eb..966b54633bcd 100644
--- a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Repositories.cs
+++ b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Repositories.cs
@@ -47,6 +47,7 @@ internal static IUmbracoBuilder AddRepositories(this IUmbracoBuilder builder)
             builder.Services.AddUnique<IPublicAccessRepository, PublicAccessRepository>();
             builder.Services.AddUnique<IRedirectUrlRepository, RedirectUrlRepository>();
             builder.Services.AddUnique<IRelationRepository, RelationRepository>();
+            builder.Services.AddUnique<ITrackedReferencesRepository, TrackedReferencesRepository>();
             builder.Services.AddUnique<IRelationTypeRepository, RelationTypeRepository>();
             builder.Services.AddUnique<IServerRegistrationRepository, ServerRegistrationRepository>();
             builder.Services.AddUnique<ITagRepository, TagRepository>();
diff --git a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Services.cs b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Services.cs
index 90d08b93fed0..915b8150330e 100644
--- a/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Services.cs
+++ b/src/Umbraco.Infrastructure/DependencyInjection/UmbracoBuilder.Services.cs
@@ -63,6 +63,7 @@ internal static IUmbracoBuilder AddServices(this IUmbracoBuilder builder)
             builder.Services.AddUnique<IServerRegistrationService, ServerRegistrationService>();
             builder.Services.AddUnique<IEntityService, EntityService>();
             builder.Services.AddUnique<IRelationService, RelationService>();
+            builder.Services.AddUnique<ITrackedReferencesService, TrackedReferencesService>();
             builder.Services.AddUnique<IMacroService, MacroService>();
             builder.Services.AddUnique<IMemberTypeService, MemberTypeService>();
             builder.Services.AddUnique<IMemberGroupService, MemberGroupService>();
diff --git a/src/Umbraco.Infrastructure/Events/RelateOnTrashNotificationHandler.cs b/src/Umbraco.Infrastructure/Events/RelateOnTrashNotificationHandler.cs
index 4222ac800e44..b06248c79e10 100644
--- a/src/Umbraco.Infrastructure/Events/RelateOnTrashNotificationHandler.cs
+++ b/src/Umbraco.Infrastructure/Events/RelateOnTrashNotificationHandler.cs
@@ -65,7 +65,7 @@ public void Handle(ContentMovedToRecycleBinNotification notification)
                     var documentObjectType = Constants.ObjectTypes.Document;
                     const string relationTypeName = Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteName;
 
-                    relationType = new RelationType(relationTypeName, relationTypeAlias, false, documentObjectType, documentObjectType);
+                    relationType = new RelationType(relationTypeName, relationTypeAlias, false, documentObjectType, documentObjectType, false);
                     _relationService.Save(relationType);
                 }
 
@@ -123,7 +123,7 @@ public void Handle(MediaMovedToRecycleBinNotification notification)
                 {
                     var documentObjectType = Constants.ObjectTypes.Document;
                     const string relationTypeName = Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName;
-                    relationType = new RelationType(relationTypeName, relationTypeAlias, false, documentObjectType, documentObjectType);
+                    relationType = new RelationType(relationTypeName, relationTypeAlias, false, documentObjectType, documentObjectType, false);
                     _relationService.Save(relationType);
                 }
 
diff --git a/src/Umbraco.Infrastructure/Migrations/Install/DatabaseDataCreator.cs b/src/Umbraco.Infrastructure/Migrations/Install/DatabaseDataCreator.cs
index 25dadb0c858a..b19802996bd7 100644
--- a/src/Umbraco.Infrastructure/Migrations/Install/DatabaseDataCreator.cs
+++ b/src/Umbraco.Infrastructure/Migrations/Install/DatabaseDataCreator.cs
@@ -421,21 +421,21 @@ void InsertDataTypeDto(int id, string editorAlias, string dbType, string configu
 
         private void CreateRelationTypeData()
         {
-            var relationType = new RelationTypeDto { Id = 1, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Document, ParentObjectType = Cms.Core.Constants.ObjectTypes.Document, Dual = true, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateDocumentOnCopyName };
+            var relationType = new RelationTypeDto { Id = 1, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Document, ParentObjectType = Cms.Core.Constants.ObjectTypes.Document, Dual = true, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateDocumentOnCopyName, IsDependency = false};
             relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
-            relationType = new RelationTypeDto { Id = 2, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Document, ParentObjectType = Cms.Core.Constants.ObjectTypes.Document, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteName };
+            relationType = new RelationTypeDto { Id = 2, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Document, ParentObjectType = Cms.Core.Constants.ObjectTypes.Document, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteName, IsDependency = false };
             relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
-            relationType = new RelationTypeDto { Id = 3, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Media, ParentObjectType = Cms.Core.Constants.ObjectTypes.Media, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName };
+            relationType = new RelationTypeDto { Id = 3, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias, ChildObjectType = Cms.Core.Constants.ObjectTypes.Media, ParentObjectType = Cms.Core.Constants.ObjectTypes.Media, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName, IsDependency = false };
             relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
 
-            relationType = new RelationTypeDto { Id = 4, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelatedMediaAlias, ChildObjectType = null, ParentObjectType = null, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelatedMediaName };
+            relationType = new RelationTypeDto { Id = 4, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelatedMediaAlias, ChildObjectType = null, ParentObjectType = null, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelatedMediaName, IsDependency = true };
             relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
 
-            relationType = new RelationTypeDto { Id = 5, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelatedDocumentAlias, ChildObjectType = null, ParentObjectType = null, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelatedDocumentName };
+            relationType = new RelationTypeDto { Id = 5, Alias = Cms.Core.Constants.Conventions.RelationTypes.RelatedDocumentAlias, ChildObjectType = null, ParentObjectType = null, Dual = false, Name = Cms.Core.Constants.Conventions.RelationTypes.RelatedDocumentName, IsDependency = true };
             relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
             _database.Insert(Cms.Core.Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
         }
diff --git a/src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs b/src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs
index 11de1209b332..d3a920a60b4a 100644
--- a/src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs
+++ b/src/Umbraco.Infrastructure/Migrations/Upgrade/UmbracoPlan.cs
@@ -283,6 +283,7 @@ protected void DefinePlan()
 
             // TO 9.4.0
             To<AddScheduledPublishingLock>("{DBBA1EA0-25A1-4863-90FB-5D306FB6F1E1}");
+            To<UpdateRelationTypesToHandleDependencies>("{DED98755-4059-41BB-ADBD-3FEAB12D1D7B}");
         }
     }
 }
diff --git a/src/Umbraco.Infrastructure/Migrations/Upgrade/V_9_4_0/UpdateRelationTypesToHandleDependencies.cs b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_9_4_0/UpdateRelationTypesToHandleDependencies.cs
new file mode 100644
index 000000000000..1c8fe7ed7201
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Migrations/Upgrade/V_9_4_0/UpdateRelationTypesToHandleDependencies.cs
@@ -0,0 +1,34 @@
+using System.Linq;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos;
+using Umbraco.Extensions;
+
+
+namespace Umbraco.Cms.Infrastructure.Migrations.Upgrade.V_9_4_0
+{
+    internal class UpdateRelationTypesToHandleDependencies : MigrationBase
+    {
+        public UpdateRelationTypesToHandleDependencies(IMigrationContext context)
+            : base(context)
+        {
+        }
+
+        protected override void Migrate()
+        {
+            var columns = SqlSyntax.GetColumnsInSchema(Context.Database).ToList();
+
+            AddColumnIfNotExists<RelationTypeDto>(columns, "isDependency");
+
+            var aliasesWithDependencies = new[]
+            {
+                Core.Constants.Conventions.RelationTypes.RelatedDocumentAlias,
+                Core.Constants.Conventions.RelationTypes.RelatedMediaAlias
+            };
+
+            Database.Execute(
+                Sql()
+                    .Update<RelationTypeDto>(u => u.Set(x => x.IsDependency, true))
+                    .WhereIn<RelationTypeDto>(x => x.Alias, aliasesWithDependencies));
+
+        }
+    }
+}
diff --git a/src/Umbraco.Infrastructure/Persistence/Dtos/RelationTypeDto.cs b/src/Umbraco.Infrastructure/Persistence/Dtos/RelationTypeDto.cs
index 50d7960ff8ff..388fa58941ae 100644
--- a/src/Umbraco.Infrastructure/Persistence/Dtos/RelationTypeDto.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Dtos/RelationTypeDto.cs
@@ -40,5 +40,9 @@ internal class RelationTypeDto
         [Length(100)]
         [Index(IndexTypes.UniqueNonClustered, Name = "IX_umbracoRelationType_alias")]
         public string Alias { get; set; }
+
+        [Constraint(Default = "0")]
+        [Column("isDependency")]
+        public bool IsDependency { get; set; }
     }
 }
diff --git a/src/Umbraco.Infrastructure/Persistence/Factories/RelationTypeFactory.cs b/src/Umbraco.Infrastructure/Persistence/Factories/RelationTypeFactory.cs
index 51f5261199b8..93cb74cd7430 100644
--- a/src/Umbraco.Infrastructure/Persistence/Factories/RelationTypeFactory.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Factories/RelationTypeFactory.cs
@@ -9,7 +9,7 @@ internal static class RelationTypeFactory
 
         public static IRelationType BuildEntity(RelationTypeDto dto)
         {
-            var entity = new RelationType(dto.Name, dto.Alias, dto.Dual, dto.ParentObjectType, dto.ChildObjectType);
+            var entity = new RelationType(dto.Name, dto.Alias, dto.Dual, dto.ParentObjectType, dto.ChildObjectType, dto.IsDependency);
 
             try
             {
@@ -30,11 +30,17 @@ public static IRelationType BuildEntity(RelationTypeDto dto)
 
         public static RelationTypeDto BuildDto(IRelationType entity)
         {
+            var isDependency = false;
+            if (entity is IRelationTypeWithIsDependency relationTypeWithIsDependency)
+            {
+                isDependency = relationTypeWithIsDependency.IsDependency;
+            }
             var dto = new RelationTypeDto
             {
                 Alias = entity.Alias,
                 ChildObjectType = entity.ChildObjectType,
                 Dual = entity.IsBidirectional,
+                IsDependency = isDependency,
                 Name = entity.Name,
                 ParentObjectType = entity.ParentObjectType,
                 UniqueId = entity.Key
@@ -47,6 +53,8 @@ public static RelationTypeDto BuildDto(IRelationType entity)
             return dto;
         }
 
+
+
         #endregion
     }
 }
diff --git a/src/Umbraco.Infrastructure/Persistence/Mappers/RelationTypeMapper.cs b/src/Umbraco.Infrastructure/Persistence/Mappers/RelationTypeMapper.cs
index 965a659631f7..732563fef7ca 100644
--- a/src/Umbraco.Infrastructure/Persistence/Mappers/RelationTypeMapper.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Mappers/RelationTypeMapper.cs
@@ -22,6 +22,7 @@ protected override void DefineMaps()
             DefineMap<RelationType, RelationTypeDto>(nameof(RelationType.Alias), nameof(RelationTypeDto.Alias));
             DefineMap<RelationType, RelationTypeDto>(nameof(RelationType.ChildObjectType), nameof(RelationTypeDto.ChildObjectType));
             DefineMap<RelationType, RelationTypeDto>(nameof(RelationType.IsBidirectional), nameof(RelationTypeDto.Dual));
+            DefineMap<RelationType, RelationTypeDto>(nameof(RelationType.IsDependency), nameof(RelationTypeDto.IsDependency));
             DefineMap<RelationType, RelationTypeDto>(nameof(RelationType.Name), nameof(RelationTypeDto.Name));
             DefineMap<RelationType, RelationTypeDto>(nameof(RelationType.ParentObjectType), nameof(RelationTypeDto.ParentObjectType));
         }
diff --git a/src/Umbraco.Infrastructure/Persistence/NPocoSqlExtensions.cs b/src/Umbraco.Infrastructure/Persistence/NPocoSqlExtensions.cs
index 05f15f7372cb..bd48f177d4c6 100644
--- a/src/Umbraco.Infrastructure/Persistence/NPocoSqlExtensions.cs
+++ b/src/Umbraco.Infrastructure/Persistence/NPocoSqlExtensions.cs
@@ -72,7 +72,27 @@ public static Sql<ISqlContext> WhereIn<TDto>(this Sql<ISqlContext> sql, Expressi
         /// <returns>The Sql statement.</returns>
         public static Sql<ISqlContext> WhereIn<TDto>(this Sql<ISqlContext> sql, Expression<Func<TDto, object>> field, Sql<ISqlContext> values)
         {
-            return sql.WhereIn(field, values, false);
+            return WhereIn(sql, field, values, false, null);
+        }
+
+        public static Sql<ISqlContext> WhereIn<TDto>(this Sql<ISqlContext> sql, Expression<Func<TDto, object>> field, Sql<ISqlContext> values, string tableAlias)
+        {
+            return sql.WhereIn(field, values, false, tableAlias);
+        }
+
+
+        public static Sql<ISqlContext> WhereLike<TDto>(this Sql<ISqlContext> sql, Expression<Func<TDto, object>> fieldSelector, Sql<ISqlContext> valuesSql)
+        {
+            var fieldName = sql.SqlContext.SqlSyntax.GetFieldName(fieldSelector);
+            sql.Where(fieldName + " LIKE (" + valuesSql.SQL + ")", valuesSql.Arguments);
+            return sql;
+        }
+
+        public static Sql<ISqlContext> WhereLike<TDto>(this Sql<ISqlContext> sql, Expression<Func<TDto, object>> fieldSelector, string likeValue)
+        {
+            var fieldName = sql.SqlContext.SqlSyntax.GetFieldName(fieldSelector);
+            sql.Where(fieldName + " LIKE ('" + likeValue + "')");
+            return sql;
         }
 
         /// <summary>
@@ -130,7 +150,12 @@ public static Sql WhereAnyIn<TDto>(this Sql<ISqlContext> sql, Expression<Func<TD
 
         private static Sql<ISqlContext> WhereIn<T>(this Sql<ISqlContext> sql, Expression<Func<T, object>> fieldSelector, Sql valuesSql, bool not)
         {
-            var fieldName = sql.SqlContext.SqlSyntax.GetFieldName(fieldSelector);
+            return WhereIn(sql, fieldSelector, valuesSql, not, null);
+        }
+
+        private static Sql<ISqlContext> WhereIn<T>(this Sql<ISqlContext> sql, Expression<Func<T, object>> fieldSelector, Sql valuesSql, bool not, string tableAlias)
+        {
+            var fieldName = sql.SqlContext.SqlSyntax.GetFieldName(fieldSelector, tableAlias);
             sql.Where(fieldName + (not ? " NOT" : "") +" IN (" + valuesSql.SQL + ")", valuesSql.Arguments);
             return sql;
         }
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/RelationRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/RelationRepository.cs
index 749fc9d77bd1..a18782ca8248 100644
--- a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/RelationRepository.cs
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/RelationRepository.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Linq.Expressions;
 using Microsoft.Extensions.Logging;
 using NPoco;
 using Umbraco.Cms.Core;
@@ -171,6 +172,11 @@ private void SqlJoinRelations(Sql<ISqlContext> sql)
         }
 
         public IEnumerable<IUmbracoEntity> GetPagedParentEntitiesByChildId(int childId, long pageIndex, int pageSize, out long totalRecords, params Guid[] entityTypes)
+        {
+            return GetPagedParentEntitiesByChildId(childId, pageIndex, pageSize, out totalRecords, new int[0], entityTypes);
+        }
+
+        public IEnumerable<IUmbracoEntity> GetPagedParentEntitiesByChildId(int childId, long pageIndex, int pageSize, out long totalRecords, int[] relationTypes, params Guid[] entityTypes)
         {
             // var contentObjectTypes = new[] { Constants.ObjectTypes.Document, Constants.ObjectTypes.Media, Constants.ObjectTypes.Member }
             // we could pass in the contentObjectTypes so that the entity repository sql is configured to do full entity lookups so that we get the full data
@@ -184,10 +190,36 @@ public IEnumerable<IUmbracoEntity> GetPagedParentEntitiesByChildId(int childId,
 
                 sql.Where<RelationDto>(rel => rel.ChildId == childId);
                 sql.Where<RelationDto, NodeDto>((rel, node) => rel.ParentId == childId || node.NodeId != childId);
+
+                if (relationTypes != null && relationTypes.Any())
+                {
+                    sql.WhereIn<RelationDto>(rel => rel.RelationType, relationTypes);
+                }
+            });
+        }
+
+        public IEnumerable<IUmbracoEntity> GetPagedParentEntitiesByChildIds(int[] childIds, long pageIndex, int pageSize, out long totalRecords, int[] relationTypes, params Guid[] entityTypes)
+        {
+            return _entityRepository.GetPagedResultsByQuery(Query<IUmbracoEntity>(), entityTypes, pageIndex, pageSize, out totalRecords, null, null, sql =>
+            {
+                SqlJoinRelations(sql);
+
+                sql.WhereIn<RelationDto>(rel => rel.ChildId, childIds);
+                sql.WhereAny(s => s.WhereIn<RelationDto>(rel => rel.ParentId, childIds), s => s.WhereNotIn<NodeDto>(node => node.NodeId, childIds));
+
+                if (relationTypes != null && relationTypes.Any())
+                {
+                    sql.WhereIn<RelationDto>(rel => rel.RelationType, relationTypes);
+                }
             });
         }
 
         public IEnumerable<IUmbracoEntity> GetPagedChildEntitiesByParentId(int parentId, long pageIndex, int pageSize, out long totalRecords, params Guid[] entityTypes)
+        {
+            return GetPagedChildEntitiesByParentId(parentId, pageIndex, pageSize, out totalRecords, new int[0], entityTypes);
+        }
+
+        public IEnumerable<IUmbracoEntity> GetPagedChildEntitiesByParentId(int parentId, long pageIndex, int pageSize, out long totalRecords, int[] relationTypes, params Guid[] entityTypes)
         {
             // var contentObjectTypes = new[] { Constants.ObjectTypes.Document, Constants.ObjectTypes.Media, Constants.ObjectTypes.Member }
             // we could pass in the contentObjectTypes so that the entity repository sql is configured to do full entity lookups so that we get the full data
@@ -201,9 +233,29 @@ public IEnumerable<IUmbracoEntity> GetPagedChildEntitiesByParentId(int parentId,
 
                 sql.Where<RelationDto>(rel => rel.ParentId == parentId);
                 sql.Where<RelationDto, NodeDto>((rel, node) => rel.ChildId == parentId || node.NodeId != parentId);
+
+                if (relationTypes != null && relationTypes.Any())
+                {
+                    sql.WhereIn<RelationDto>(rel => rel.RelationType, relationTypes);
+                }
             });
         }
 
+        public IEnumerable<IUmbracoEntity> GetPagedEntitiesForItemsInRelation(int[] itemIds, long pageIndex, int pageSize, out long totalRecords, params Guid[] entityTypes)
+        {
+            return _entityRepository.GetPagedResultsByQuery(Query<IUmbracoEntity>(), entityTypes, pageIndex, pageSize, out totalRecords, null, null, sql =>
+            {
+                SqlJoinRelations(sql);
+
+                sql.WhereIn<RelationDto>(rel => rel.ChildId, itemIds);
+                sql.Where<RelationDto, NodeDto>((rel, node) => rel.ChildId == node.NodeId);
+                sql.Where<RelationTypeDto>(type => type.IsDependency);
+            });
+        }
+
+
+
+
         public void Save(IEnumerable<IRelation> relations)
         {
             foreach (var hasIdentityGroup in relations.GroupBy(r => r.HasIdentity))
@@ -399,4 +451,42 @@ private void ApplyOrdering(ref Sql<ISqlContext> sql, Ordering ordering)
                 sql.OrderByDescending(orderBy);
         }
     }
+
+    internal class RelationItemDto
+    {
+        [Column(Name = "nodeId")]
+        public int ChildNodeId { get; set; }
+
+        [Column(Name = "nodeKey")]
+        public Guid ChildNodeKey { get; set; }
+
+        [Column(Name = "nodeName")]
+        public string ChildNodeName { get; set; }
+
+        [Column(Name = "nodeObjectType")]
+        public Guid ChildNodeObjectType { get; set; }
+
+        [Column(Name = "contentTypeIcon")]
+        public string ChildContentTypeIcon { get; set; }
+
+        [Column(Name = "contentTypeAlias")]
+        public string ChildContentTypeAlias { get; set; }
+
+        [Column(Name = "contentTypeName")]
+        public string ChildContentTypeName { get; set; }
+
+
+
+        [Column(Name = "relationTypeName")]
+        public string RelationTypeName { get; set; }
+
+        [Column(Name = "relationTypeAlias")]
+        public string RelationTypeAlias { get; set; }
+
+        [Column(Name = "relationTypeIsDependency")]
+        public bool RelationTypeIsDependency { get; set; }
+
+        [Column(Name = "relationTypeIsBidirectional")]
+        public bool RelationTypeIsBidirectional { get; set; }
+    }
 }
diff --git a/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/TrackedReferencesRepository.cs b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/TrackedReferencesRepository.cs
new file mode 100644
index 000000000000..f5fb94546460
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Persistence/Repositories/Implement/TrackedReferencesRepository.cs
@@ -0,0 +1,194 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NPoco;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Persistence;
+using Umbraco.Cms.Core.Persistence.Repositories;
+using Umbraco.Cms.Core.Scoping;
+using Umbraco.Cms.Infrastructure.Persistence.Dtos;
+using Umbraco.Extensions;
+
+namespace Umbraco.Cms.Infrastructure.Persistence.Repositories.Implement
+{
+    internal class TrackedReferencesRepository : ITrackedReferencesRepository
+    {
+        private readonly IScopeAccessor _scopeAccessor;
+
+        public TrackedReferencesRepository(IScopeAccessor scopeAccessor)
+        {
+            _scopeAccessor = scopeAccessor;
+        }
+
+        public IEnumerable<RelationItem> GetPagedItemsWithRelations(int[] ids, long pageIndex, int pageSize,
+            bool filterMustBeIsDependency, out long totalRecords)
+        {
+            var sql = _scopeAccessor.AmbientScope.Database.SqlContext.Sql().Select(
+                    "[pn].[id] as nodeId",
+                    "[pn].[uniqueId] as nodeKey",
+                    "[pn].[text] as nodeName",
+                    "[pn].[nodeObjectType] as nodeObjectType",
+                    "[ct].[icon] as contentTypeIcon",
+                    "[ct].[alias] as contentTypeAlias",
+                    "[ctn].[text] as contentTypeName",
+                    "[umbracoRelationType].[alias] as relationTypeAlias",
+                    "[umbracoRelationType].[name] as relationTypeName",
+                    "[umbracoRelationType].[isDependency] as relationTypeIsDependency",
+                    "[umbracoRelationType].[dual] as relationTypeIsBidirectional")
+                .From<RelationDto>("r")
+                .InnerJoin<RelationTypeDto>("umbracoRelationType").On<RelationDto, RelationTypeDto>((left, right) => left.RelationType == right.Id, aliasLeft: "r", aliasRight:"umbracoRelationType")
+                .InnerJoin<NodeDto>("cn").On<RelationDto, NodeDto, RelationTypeDto>((r, cn, rt) => (!rt.Dual && r.ParentId == cn.NodeId) || (rt.Dual && (r.ChildId == cn.NodeId || r.ParentId == cn.NodeId )), aliasLeft: "r", aliasRight:"cn", aliasOther: "umbracoRelationType" )
+                .InnerJoin<NodeDto>("pn").On<RelationDto, NodeDto, NodeDto>((r, pn, cn) => (pn.NodeId == r.ChildId && cn.NodeId == r.ParentId) || (pn.NodeId == r.ParentId && cn.NodeId == r.ChildId), aliasLeft: "r", aliasRight:"pn", aliasOther:"cn" )
+                .LeftJoin<ContentDto>("c").On<NodeDto, ContentDto>((left, right) => left.NodeId == right.NodeId, aliasLeft:"pn", aliasRight:"c")
+                .LeftJoin<ContentTypeDto>("ct").On<ContentDto, ContentTypeDto>((left, right) => left.ContentTypeId == right.NodeId, aliasLeft:"c",  aliasRight:"ct")
+                .LeftJoin<NodeDto>("ctn").On<ContentTypeDto, NodeDto>((left, right) => left.NodeId == right.NodeId, aliasLeft:"ct",  aliasRight:"ctn");
+
+            if (ids.Any())
+            {
+                sql = sql.Where<NodeDto>(x => ids.Contains(x.NodeId), "pn");
+            }
+
+            if (filterMustBeIsDependency)
+            {
+                sql = sql.Where<RelationTypeDto>(rt => rt.IsDependency, "umbracoRelationType");
+            }
+
+            // Ordering is required for paging
+            sql = sql.OrderBy<RelationTypeDto>(x => x.Alias);
+
+            var pagedResult = _scopeAccessor.AmbientScope.Database.Page<RelationItemDto>(pageIndex + 1, pageSize, sql);
+            totalRecords = Convert.ToInt32(pagedResult.TotalItems);
+
+            return pagedResult.Items.Select(MapDtoToEntity);
+        }
+
+        public IEnumerable<RelationItem> GetPagedDescendantsInReferences(int parentId, long pageIndex, int pageSize, bool filterMustBeIsDependency,
+            out long totalRecords)
+        {
+            var syntax = _scopeAccessor.AmbientScope.Database.SqlContext.SqlSyntax;
+
+            // Gets the path of the parent with ",%" added
+            var subsubQuery = _scopeAccessor.AmbientScope.Database.SqlContext.Sql()
+                .Select(syntax.GetConcat("[node].[path]", "',%'"))
+                .From<NodeDto>("node")
+                .Where<NodeDto>(x => x.NodeId == parentId, "node");
+
+
+            // Gets the descendants of the parent node
+            Sql<ISqlContext> subQuery;
+
+            if (_scopeAccessor.AmbientScope.Database.DatabaseType.IsSqlCe())
+            {
+                // SqlCE do not support nested selects that returns a scalar. So we need to do this in multiple queries
+
+                var pathForLike = _scopeAccessor.AmbientScope.Database.ExecuteScalar<string>(subsubQuery);
+
+                subQuery = _scopeAccessor.AmbientScope.Database.SqlContext.Sql()
+                    .Select<NodeDto>(x => x.NodeId)
+                    .From<NodeDto>()
+                    .WhereLike<NodeDto>(x => x.Path, pathForLike);
+            }
+            else
+            {
+                subQuery = _scopeAccessor.AmbientScope.Database.SqlContext.Sql()
+                    .Select<NodeDto>(x => x.NodeId)
+                    .From<NodeDto>()
+                    .WhereLike<NodeDto>(x => x.Path, subsubQuery);
+            }
+
+
+
+            // Get all relations where parent is in the sub query
+            var sql = _scopeAccessor.AmbientScope.Database.SqlContext.Sql().Select(
+                    "[pn].[id] as nodeId",
+                    "[pn].[uniqueId] as nodeKey",
+                    "[pn].[text] as nodeName",
+                    "[pn].[nodeObjectType] as nodeObjectType",
+                    "[ct].[icon] as contentTypeIcon",
+                    "[ct].[alias] as contentTypeAlias",
+                    "[ctn].[text] as contentTypeName",
+                    "[umbracoRelationType].[alias] as relationTypeAlias",
+                    "[umbracoRelationType].[name] as relationTypeName",
+                    "[umbracoRelationType].[isDependency] as relationTypeIsDependency",
+                    "[umbracoRelationType].[dual] as relationTypeIsBidirectional")
+                .From<RelationDto>("r")
+                .InnerJoin<RelationTypeDto>("umbracoRelationType").On<RelationDto, RelationTypeDto>((left, right) => left.RelationType == right.Id, aliasLeft: "r", aliasRight:"umbracoRelationType")
+                .InnerJoin<NodeDto>("cn").On<RelationDto, NodeDto, RelationTypeDto>((r, cn, rt) => (!rt.Dual && r.ParentId == cn.NodeId) || (rt.Dual && (r.ChildId == cn.NodeId || r.ParentId == cn.NodeId )), aliasLeft: "r", aliasRight:"cn", aliasOther: "umbracoRelationType" )
+                .InnerJoin<NodeDto>("pn").On<RelationDto, NodeDto, NodeDto>((r, pn, cn) => (pn.NodeId == r.ChildId && cn.NodeId == r.ParentId) || (pn.NodeId == r.ParentId && cn.NodeId == r.ChildId), aliasLeft: "r", aliasRight:"pn", aliasOther:"cn" )
+                .LeftJoin<ContentDto>("c").On<NodeDto, ContentDto>((left, right) => left.NodeId == right.NodeId, aliasLeft:"pn", aliasRight:"c")
+                .LeftJoin<ContentTypeDto>("ct").On<ContentDto, ContentTypeDto>((left, right) => left.ContentTypeId == right.NodeId, aliasLeft:"c",  aliasRight:"ct")
+                .LeftJoin<NodeDto>("ctn").On<ContentTypeDto, NodeDto>((left, right) => left.NodeId == right.NodeId, aliasLeft:"ct",  aliasRight:"ctn")
+                .WhereIn((System.Linq.Expressions.Expression<Func<NodeDto, object>>)(x => x.NodeId), subQuery, "pn");
+            if (filterMustBeIsDependency)
+            {
+                sql = sql.Where<RelationTypeDto>(rt => rt.IsDependency, "umbracoRelationType");
+            }
+            // Ordering is required for paging
+            sql = sql.OrderBy<RelationTypeDto>(x => x.Alias);
+
+            var pagedResult = _scopeAccessor.AmbientScope.Database.Page<RelationItemDto>(pageIndex + 1, pageSize, sql);
+            totalRecords = Convert.ToInt32(pagedResult.TotalItems);
+
+            return pagedResult.Items.Select(MapDtoToEntity);
+        }
+
+        public IEnumerable<RelationItem> GetPagedRelationsForItems(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency, out long totalRecords)
+        {
+            var sql = _scopeAccessor.AmbientScope.Database.SqlContext.Sql().Select(
+                    "[cn].[id] as nodeId",
+                    "[cn].[uniqueId] as nodeKey",
+                    "[cn].[text] as nodeName",
+                    "[cn].[nodeObjectType] as nodeObjectType",
+                    "[ct].[icon] as contentTypeIcon",
+                    "[ct].[alias] as contentTypeAlias",
+                    "[ctn].[text] as contentTypeName",
+                    "[umbracoRelationType].[alias] as relationTypeAlias",
+                    "[umbracoRelationType].[name] as relationTypeName",
+                    "[umbracoRelationType].[isDependency] as relationTypeIsDependency",
+                    "[umbracoRelationType].[dual] as relationTypeIsBidirectional")
+                .From<RelationDto>("r")
+                .InnerJoin<RelationTypeDto>("umbracoRelationType").On<RelationDto, RelationTypeDto>((left, right) => left.RelationType == right.Id, aliasLeft: "r", aliasRight:"umbracoRelationType")
+                .InnerJoin<NodeDto>("cn").On<RelationDto, NodeDto, RelationTypeDto>((r, cn, rt) => (!rt.Dual && r.ParentId == cn.NodeId) || (rt.Dual && (r.ChildId == cn.NodeId || r.ParentId == cn.NodeId )), aliasLeft: "r", aliasRight:"cn", aliasOther: "umbracoRelationType" )
+                .InnerJoin<NodeDto>("pn").On<RelationDto, NodeDto, NodeDto>((r, pn, cn) => (pn.NodeId == r.ChildId && cn.NodeId == r.ParentId) || (pn.NodeId == r.ParentId && cn.NodeId == r.ChildId), aliasLeft: "r", aliasRight:"pn", aliasOther:"cn" )
+                .LeftJoin<ContentDto>("c").On<NodeDto, ContentDto>((left, right) => left.NodeId == right.NodeId, aliasLeft:"cn", aliasRight:"c")
+                .LeftJoin<ContentTypeDto>("ct").On<ContentDto, ContentTypeDto>((left, right) => left.ContentTypeId == right.NodeId, aliasLeft:"c",  aliasRight:"ct")
+                .LeftJoin<NodeDto>("ctn").On<ContentTypeDto, NodeDto>((left, right) => left.NodeId == right.NodeId, aliasLeft:"ct",  aliasRight:"ctn");
+
+            if (ids.Any())
+            {
+                sql = sql.Where<NodeDto>(x => ids.Contains(x.NodeId), "pn");
+            }
+
+            if (filterMustBeIsDependency)
+            {
+                sql = sql.Where<RelationTypeDto>(rt => rt.IsDependency, "umbracoRelationType");
+            }
+
+            // Ordering is required for paging
+            sql = sql.OrderBy<RelationTypeDto>(x => x.Alias);
+
+            var pagedResult = _scopeAccessor.AmbientScope.Database.Page<RelationItemDto>(pageIndex + 1, pageSize, sql);
+            totalRecords = Convert.ToInt32(pagedResult.TotalItems);
+
+            return pagedResult.Items.Select(MapDtoToEntity);
+        }
+
+        private RelationItem MapDtoToEntity(RelationItemDto dto)
+        {
+            var type = ObjectTypes.GetUdiType(dto.ChildNodeObjectType);
+            return new RelationItem()
+            {
+                NodeId = dto.ChildNodeId,
+                NodeKey = dto.ChildNodeKey,
+                NodeType = ObjectTypes.GetUdiType(dto.ChildNodeObjectType),
+                NodeName = dto.ChildNodeName,
+                RelationTypeName = dto.RelationTypeName,
+                RelationTypeIsBidirectional = dto.RelationTypeIsBidirectional,
+                RelationTypeIsDependency = dto.RelationTypeIsDependency,
+                ContentTypeAlias = dto.ChildContentTypeAlias,
+                ContentTypeIcon = dto.ChildContentTypeIcon,
+                ContentTypeName = dto.ChildContentTypeName,
+            };
+        }
+    }
+}
diff --git a/src/Umbraco.Infrastructure/Services/Implement/RelationService.cs b/src/Umbraco.Infrastructure/Services/Implement/RelationService.cs
index 7a5d10c222bf..d52411a9c8f4 100644
--- a/src/Umbraco.Infrastructure/Services/Implement/RelationService.cs
+++ b/src/Umbraco.Infrastructure/Services/Implement/RelationService.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.Extensions.Logging;
diff --git a/src/Umbraco.Infrastructure/Services/Implement/TrackedReferencesService.cs b/src/Umbraco.Infrastructure/Services/Implement/TrackedReferencesService.cs
new file mode 100644
index 000000000000..0f1eefb6f2de
--- /dev/null
+++ b/src/Umbraco.Infrastructure/Services/Implement/TrackedReferencesService.cs
@@ -0,0 +1,50 @@
+using System.Linq;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Persistence.Repositories;
+using Umbraco.Cms.Core.Scoping;
+
+namespace Umbraco.Cms.Core.Services.Implement
+{
+    public class TrackedReferencesService : ITrackedReferencesService
+    {
+        private readonly ITrackedReferencesRepository _trackedReferencesRepository;
+        private readonly IScopeProvider _scopeProvider;
+        private readonly IEntityService _entityService;
+
+        public TrackedReferencesService(ITrackedReferencesRepository trackedReferencesRepository, IScopeProvider scopeProvider, IEntityService entityService)
+        {
+            _trackedReferencesRepository = trackedReferencesRepository;
+            _scopeProvider = scopeProvider;
+            _entityService = entityService;
+        }
+
+        public PagedResult<RelationItem> GetPagedRelationsForItems(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency)
+        {
+            using IScope scope = _scopeProvider.CreateScope(autoComplete: true);
+            var items =  _trackedReferencesRepository.GetPagedRelationsForItems(ids, pageIndex, pageSize,  filterMustBeIsDependency, out var totalItems);
+
+            return new PagedResult<RelationItem>(totalItems, pageIndex, pageSize) { Items = items };
+        }
+
+        public PagedResult<RelationItem> GetPagedItemsWithRelations(int[] ids, long pageIndex, int pageSize, bool filterMustBeIsDependency)
+        {
+            using IScope scope = _scopeProvider.CreateScope(autoComplete: true);
+            var items =  _trackedReferencesRepository.GetPagedItemsWithRelations(ids, pageIndex, pageSize,  filterMustBeIsDependency, out var totalItems);
+
+            return new PagedResult<RelationItem>(totalItems, pageIndex, pageSize) { Items = items };
+        }
+
+        public PagedResult<RelationItem> GetPagedDescendantsInReferences(int parentId, long pageIndex, int pageSize, bool filterMustBeIsDependency)
+        {
+            using IScope scope = _scopeProvider.CreateScope(autoComplete: true);
+
+            var items = _trackedReferencesRepository.GetPagedDescendantsInReferences(
+                parentId,
+                pageIndex,
+                pageSize,
+                filterMustBeIsDependency,
+                out var totalItems);
+            return new PagedResult<RelationItem>(totalItems, pageIndex, pageSize) { Items = items };
+        }
+    }
+}
diff --git a/src/Umbraco.Web.BackOffice/Controllers/BackOfficeServerVariables.cs b/src/Umbraco.Web.BackOffice/Controllers/BackOfficeServerVariables.cs
index 0d9d8b903d58..b74c4ea7b07c 100644
--- a/src/Umbraco.Web.BackOffice/Controllers/BackOfficeServerVariables.cs
+++ b/src/Umbraco.Web.BackOffice/Controllers/BackOfficeServerVariables.cs
@@ -100,7 +100,7 @@ internal async Task<Dictionary<string, object>> BareMinimumServerVariablesAsync(
             var keepOnlyKeys = new Dictionary<string, string[]>
             {
                 {"umbracoUrls", new[] {"authenticationApiBaseUrl", "serverVarsJs", "externalLoginsUrl", "currentUserApiBaseUrl", "previewHubUrl", "iconApiBaseUrl"}},
-                {"umbracoSettings", new[] {"allowPasswordReset", "imageFileTypes", "maxFileSize", "loginBackgroundImage", "loginLogoImage", "canSendRequiredEmail", "usernameIsEmail", "minimumPasswordLength", "minimumPasswordNonAlphaNum", "hideBackofficeLogo"}},
+                {"umbracoSettings", new[] {"allowPasswordReset", "imageFileTypes", "maxFileSize", "loginBackgroundImage", "loginLogoImage", "canSendRequiredEmail", "usernameIsEmail", "minimumPasswordLength", "minimumPasswordNonAlphaNum", "hideBackofficeLogo", "disableDeleteWhenReferenced", "disableUnpublishWhenReferenced"}},
                 {"application", new[] {"applicationPath", "cacheBuster"}},
                 {"isDebuggingEnabled", new string[] { }},
                 {"features", new [] {"disabledFeatures"}}
@@ -378,6 +378,10 @@ internal async Task<Dictionary<string, object>> GetServerVariablesAsync()
                         {
                             "previewHubUrl", _previewRoutes.GetPreviewHubRoute()
                         },
+                        {
+                            "trackedReferencesApiBaseUrl", _linkGenerator.GetUmbracoApiServiceBaseUrl<TrackedReferencesController>(
+                                controller => controller.GetPagedReferences(0,  1, 1, false))
+                        }
                     }
                 },
                 {
@@ -409,6 +413,8 @@ internal async Task<Dictionary<string, object>> GetServerVariablesAsync()
                         {"loginBackgroundImage", _contentSettings.LoginBackgroundImage},
                         {"loginLogoImage", _contentSettings.LoginLogoImage },
                         {"hideBackofficeLogo", _contentSettings.HideBackOfficeLogo },
+                        {"disableDeleteWhenReferenced", _contentSettings.DisableDeleteWhenReferenced },
+                        {"disableUnpublishWhenReferenced", _contentSettings.DisableUnpublishWhenReferenced },
                         {"showUserInvite", _emailSender.CanSendRequiredEmail()},
                         {"canSendRequiredEmail", _emailSender.CanSendRequiredEmail()},
                         {"showAllowSegmentationForDocumentTypes", false},
diff --git a/src/Umbraco.Web.BackOffice/Controllers/MediaController.cs b/src/Umbraco.Web.BackOffice/Controllers/MediaController.cs
index 14a90805864e..ab832dec84fe 100644
--- a/src/Umbraco.Web.BackOffice/Controllers/MediaController.cs
+++ b/src/Umbraco.Web.BackOffice/Controllers/MediaController.cs
@@ -33,12 +33,9 @@
 using Umbraco.Cms.Core.Services;
 using Umbraco.Cms.Core.Strings;
 using Umbraco.Cms.Infrastructure.Persistence;
-using Umbraco.Cms.Web.BackOffice.ActionResults;
 using Umbraco.Cms.Web.BackOffice.Authorization;
-using Umbraco.Cms.Web.BackOffice.Extensions;
 using Umbraco.Cms.Web.BackOffice.Filters;
 using Umbraco.Cms.Web.BackOffice.ModelBinders;
-using Umbraco.Cms.Web.Common.ActionsResults;
 using Umbraco.Cms.Web.Common.Attributes;
 using Umbraco.Cms.Web.Common.Authorization;
 using Umbraco.Extensions;
@@ -1001,7 +998,7 @@ private ActionResult<IMedia> ValidateMoveOrCopy(MoveOrCopy model)
             return new ActionResult<IMedia>(toMove);
         }
 
-
+        [Obsolete("Please use TrackedReferencesController.GetPagedReferences() instead. Scheduled for removal in V11.")]
         public PagedResult<EntityBasic> GetPagedReferences(int id, string entityType, int pageNumber = 1, int pageSize = 100)
         {
             if (pageNumber <= 0 || pageSize <= 0)
diff --git a/src/Umbraco.Web.BackOffice/Controllers/RelationTypeController.cs b/src/Umbraco.Web.BackOffice/Controllers/RelationTypeController.cs
index d63f6b0eda3f..197148a2a3d7 100644
--- a/src/Umbraco.Web.BackOffice/Controllers/RelationTypeController.cs
+++ b/src/Umbraco.Web.BackOffice/Controllers/RelationTypeController.cs
@@ -148,7 +148,8 @@ public ActionResult<int> PostCreate(RelationTypeSave relationType)
                 relationType.Name.ToSafeAlias(_shortStringHelper, true),
                 relationType.IsBidirectional,
                 relationType.ParentObjectType,
-                relationType.ChildObjectType);
+                relationType.ChildObjectType,
+                relationType.IsDependency);
 
             try
             {
diff --git a/src/Umbraco.Web.BackOffice/Controllers/TrackedReferencesController.cs b/src/Umbraco.Web.BackOffice/Controllers/TrackedReferencesController.cs
new file mode 100644
index 000000000000..2cef8d61afb2
--- /dev/null
+++ b/src/Umbraco.Web.BackOffice/Controllers/TrackedReferencesController.cs
@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.Models;
+using Umbraco.Cms.Core.Models.ContentEditing;
+using Umbraco.Cms.Core.Models.Entities;
+using Umbraco.Cms.Core.Services;
+using Umbraco.Cms.Web.BackOffice.ModelBinders;
+using Umbraco.Cms.Web.Common.Attributes;
+using Umbraco.Cms.Web.Common.Authorization;
+
+namespace Umbraco.Cms.Web.BackOffice.Controllers
+{
+    [PluginController(Constants.Web.Mvc.BackOfficeApiArea)]
+    [Authorize(Policy = AuthorizationPolicies.SectionAccessContentOrMedia)]
+    public class TrackedReferencesController : BackOfficeNotificationsController
+    {
+        private readonly ITrackedReferencesService _relationService;
+        private readonly IEntityService _entityService;
+
+        public TrackedReferencesController(ITrackedReferencesService relationService,
+            IEntityService entityService)
+        {
+            _relationService = relationService;
+            _entityService = entityService;
+        }
+
+        // Used by info tabs on content, media etc. So this is basically finding childs of relations.
+        public ActionResult<PagedResult<RelationItem>> GetPagedReferences(int id, int pageNumber = 1,
+            int pageSize = 100, bool filterMustBeIsDependency = false)
+        {
+            if (pageNumber <= 0 || pageSize <= 0)
+            {
+                return BadRequest("Both pageNumber and pageSize must be greater than zero");
+            }
+
+            return _relationService.GetPagedRelationsForItems(new []{id}, pageNumber - 1, pageSize, filterMustBeIsDependency);
+        }
+
+        // Used on delete, finds
+        public ActionResult<PagedResult<RelationItem>> GetPagedDescendantsInReferences(int parentId, int pageNumber = 1, int pageSize = 100, bool filterMustBeIsDependency = true)
+        {
+            if (pageNumber <= 0 || pageSize <= 0)
+            {
+                return BadRequest("Both pageNumber and pageSize must be greater than zero");
+            }
+
+
+            return _relationService.GetPagedDescendantsInReferences(parentId, pageNumber - 1, pageSize, filterMustBeIsDependency);
+
+        }
+
+        // Used by unpublish content. So this is basically finding parents of relations.
+        [HttpGet]
+        [HttpPost]
+        public ActionResult<PagedResult<RelationItem>> GetPagedReferencedItems([FromJsonPath] int[] ids, int pageNumber = 1, int pageSize = 100, bool filterMustBeIsDependency = true)
+        {
+            if (pageNumber <= 0 || pageSize <= 0)
+            {
+                return BadRequest("Both pageNumber and pageSize must be greater than zero");
+            }
+
+            return _relationService.GetPagedItemsWithRelations(ids, pageNumber - 1, pageSize, filterMustBeIsDependency);
+
+        }
+    }
+
+}
diff --git a/src/Umbraco.Web.UI.Client/src/common/directives/components/media/umbmedianodeinfo.directive.js b/src/Umbraco.Web.UI.Client/src/common/directives/components/media/umbmedianodeinfo.directive.js
index c07777ca60c3..2a65c67a8d34 100644
--- a/src/Umbraco.Web.UI.Client/src/common/directives/components/media/umbmedianodeinfo.directive.js
+++ b/src/Umbraco.Web.UI.Client/src/common/directives/components/media/umbmedianodeinfo.directive.js
@@ -8,22 +8,6 @@
             var evts = [];
 
             scope.allowChangeMediaType = false;
-            scope.loading = true;
-
-            scope.changeContentPageNumber = changeContentPageNumber;
-            scope.contentOptions = {};
-            scope.contentOptions.entityType = "DOCUMENT";
-            scope.hasContentReferences = false;
-
-            scope.changeMediaPageNumber = changeMediaPageNumber;
-            scope.mediaOptions = {};
-            scope.mediaOptions.entityType = "MEDIA";
-            scope.hasMediaReferences = false;
-
-            scope.changeMemberPageNumber = changeMemberPageNumber;
-            scope.memberOptions = {};
-            scope.memberOptions.entityType = "MEMBER";
-            scope.hasMemberReferences = false;
 
             function onInit() {
 
@@ -110,45 +94,6 @@
                 setMediaExtension();
             });
 
-            function changeContentPageNumber(pageNumber) {
-                scope.contentOptions.pageNumber = pageNumber;
-                loadContentRelations();
-            }
-
-            function changeMediaPageNumber(pageNumber) {
-                scope.mediaOptions.pageNumber = pageNumber;
-                loadMediaRelations();
-            }
-
-            function changeMemberPageNumber(pageNumber) {
-                scope.memberOptions.pageNumber = pageNumber;
-                loadMemberRelations();
-            }
-
-            function loadContentRelations() {
-                return mediaResource.getPagedReferences(scope.node.id, scope.contentOptions)
-                    .then(function (data) {
-                        scope.contentReferences = data;
-                        scope.hasContentReferences = data.items.length > 0;
-                    });
-            }
-
-            function loadMediaRelations() {
-                return mediaResource.getPagedReferences(scope.node.id, scope.mediaOptions)
-                    .then(data => {
-                        scope.mediaReferences = data;
-                        scope.hasMediaReferences = data.items.length > 0;
-                    });
-            }
-
-            function loadMemberRelations() {
-                return mediaResource.getPagedReferences(scope.node.id, scope.memberOptions)
-                    .then(data => {
-                        scope.memberReferences = data;
-                        scope.hasMemberReferences = data.items.length > 0;
-                    });
-            }
-
             //ensure to unregister from all events!
             scope.$on('$destroy', function () {
                 for (var e in evts) {
@@ -157,18 +102,6 @@
             });
 
             onInit();
-
-            // load media type references when the 'info' tab is first activated/switched to
-            evts.push(eventsService.on("app.tabChange", function (event, args) {
-                $timeout(function () {
-                    if (args.alias === "umbInfo") {
-
-                        $q.all([loadContentRelations(), loadMediaRelations(), loadMemberRelations()]).then(function () {
-                            scope.loading = false;
-                        });
-                    }
-                });
-            }));
         }
 
         var directive = {
diff --git a/src/Umbraco.Web.UI.Client/src/common/directives/components/references/umbtrackedreferences.component.js b/src/Umbraco.Web.UI.Client/src/common/directives/components/references/umbtrackedreferences.component.js
new file mode 100644
index 000000000000..000e87146cd7
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/common/directives/components/references/umbtrackedreferences.component.js
@@ -0,0 +1,125 @@
+(function () {
+    'use strict';
+
+    /**
+     * A component to render the tracked references of an item
+     */
+
+    function umbTrackedReferencesController($q, trackedReferencesResource, localizationService) {
+
+        var vm = this;
+
+        vm.changeReferencesPageNumber = changeReferencesPageNumber;
+        vm.changeDescendantsPageNumber = changeDescendantsPageNumber;
+
+        vm.$onInit = onInit;
+
+        function onInit() {
+
+            vm.referencesTitle = this.hideNoneDependencies ? "The following items depends on this" : "Referenced by the following items";
+            vm.referencedDescendantsTitle = this.hideNoneDependencies ? "The following descending items has dependencies" : "The following descending items are referenced";
+    
+            localizationService.localize(this.hideNoneDependencies ? "references_labelDependsOnThis" : "references_labelUsedByItems").then(function (value) {
+                vm.referencesTitle = value;
+            });
+    
+            localizationService.localize(this.hideNoneDependencies ? "references_labelDependentDescendants" : "references_labelUsedDescendants").then(function (value) {
+                vm.referencedDescendantsTitle = value;
+            });
+    
+            vm.descendantsOptions = {};
+            vm.descendantsOptions.filterMustBeIsDependency = this.hideNoneDependencies;
+            vm.hasReferencesInDescendants = false;
+
+            vm.referencesOptions = {};
+            vm.referencesOptions.filterMustBeIsDependency = this.hideNoneDependencies;
+            vm.hasReferences = false;
+
+            this.loading = true;
+            this.hideNoResult = this.hideNoResult || false;
+
+            // when vm.id == 0 it means that this is a new item, so it has no references yet
+            if (vm.id === 0) {
+                vm.loading = false;
+                if(vm.onLoadingComplete) {
+                    vm.onLoadingComplete();
+                }
+                return;
+            }
+
+            // Make array of promises to load:
+            var promises = [loadReferencesRelations()];
+
+            // only load descendants if we want to show them.
+            if (vm.showDescendants) {
+                promises.push(loadDescendantsUsage());
+            }
+
+            $q.all(promises).then(function () {
+                vm.loading = false;
+                if(vm.onLoadingComplete) {
+                    vm.onLoadingComplete();
+                }
+            });
+        }
+
+        function changeReferencesPageNumber(pageNumber) {
+            vm.referencesOptions.pageNumber = pageNumber;
+            loadReferencesRelations();
+        }
+
+        function changeDescendantsPageNumber(pageNumber) {
+            vm.descendantsOptions.pageNumber = pageNumber;
+            loadDescendantsUsage();
+        }
+
+        function loadReferencesRelations() {
+            return trackedReferencesResource.getPagedReferences(vm.id, vm.referencesOptions)
+                .then(function (data) {
+                    vm.references = data;
+
+                    if (data.items.length > 0) {
+                        vm.hasReferences = data.items.length > 0;
+                        activateWarning();
+                    }
+                });
+        }
+
+        function loadDescendantsUsage() {
+            return trackedReferencesResource.getPagedDescendantsInReferences(vm.id, vm.descendantsOptions)
+                .then(function (data) {
+                    vm.referencedDescendants = data;
+
+                    if (data.items.length > 0) {
+                        vm.hasReferencesInDescendants = data.items.length > 0;
+                        activateWarning();
+                    }
+                });
+        }
+
+        function activateWarning() {
+            if (vm.onWarning) {
+                vm.onWarning();
+            }
+        }
+    }
+
+    var umbTrackedReferencesComponent = {
+        templateUrl: 'views/components/references/umb-tracked-references.html',
+        transclude: true,
+        bindings: {
+            id: "<",
+            hideNoResult: "<?",
+            onWarning: "&?",
+            onLoadingComplete: "&?",
+            compact: "<?",
+            showDescendants: "<?",
+            hideNoneDependencies: "<?"
+        },
+        controllerAs: 'vm',
+        controller: umbTrackedReferencesController
+    };
+
+    angular.module('umbraco.directives').component('umbTrackedReferences', umbTrackedReferencesComponent);
+
+})();
diff --git a/src/Umbraco.Web.UI.Client/src/common/directives/components/references/umbtrackedreferencesbulkaction.component.js b/src/Umbraco.Web.UI.Client/src/common/directives/components/references/umbtrackedreferencesbulkaction.component.js
new file mode 100644
index 000000000000..4059a803deda
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/common/directives/components/references/umbtrackedreferencesbulkaction.component.js
@@ -0,0 +1,79 @@
+(function () {
+    'use strict';
+
+    /**
+     * A component to render the items from a selection which are used in a relation
+     */
+
+    function umbTrackedReferencesBulkActionController($q, trackedReferencesResource, localizationService)
+    {
+        var vm = this;
+
+        vm.referencedItemsTitle = "These items are referenced";
+
+        localizationService.localize("references_labelUsedItems").then(function (value) {
+            vm.referencedItemsTitle = value;
+        });
+      
+        vm.changeReferencesPageNumber = changeReferencesPageNumber;
+        vm.referencesOptions = {};
+        vm.referencesOptions.filterMustBeIsDependency = true;
+        vm.hasReferences = false;
+
+        vm.$onInit = onInit;
+
+        function onInit() {
+
+            this.loading = true;
+            this.hideNoResult = this.hideNoResult || false;
+
+            loadContentBulkActionUsage().then(function () {
+                vm.loading = false;
+                if(vm.onLoadingComplete) {
+                    vm.onLoadingComplete();
+                }
+            });
+        }
+
+        function changeReferencesPageNumber(pageNumber) {
+            vm.referencesOptions.pageNumber = pageNumber;
+            loadContentBulkActionUsage();
+        }
+
+        function loadContentBulkActionUsage() {
+             var ids = vm.selection.map(s => s.id);
+
+             return trackedReferencesResource.getPagedReferencedItems(ids, vm.referencesOptions)
+                  .then(function (data) {
+                      vm.referencedItems = data;
+
+                      if (data.items.length > 0) {
+                          vm.hasReferences = data.items.length > 0;
+                          activateWarning();
+                      }
+                  });
+        }
+
+        function activateWarning() {
+            if (vm.onWarning) {
+                vm.onWarning();
+            }
+        }
+    }
+
+    var umbTrackedReferencesBulkActionComponent = {
+        templateUrl: 'views/components/references/umb-tracked-references-bulk-action.html',
+        transclude: true,
+        bindings: {
+            selection: "<",
+            hideNoResult: "<?",
+            onWarning: "&?",
+            onLoadingComplete: "&?"
+        },
+        controllerAs: 'vm',
+        controller: umbTrackedReferencesBulkActionController
+    };
+
+    angular.module('umbraco.directives').component('umbTrackedReferencesBulkAction', umbTrackedReferencesBulkActionComponent);
+
+})();
diff --git a/src/Umbraco.Web.UI.Client/src/common/directives/components/references/umbtrackedreferencestable.component.js b/src/Umbraco.Web.UI.Client/src/common/directives/components/references/umbtrackedreferencestable.component.js
new file mode 100644
index 000000000000..4709a9a500e2
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/common/directives/components/references/umbtrackedreferencestable.component.js
@@ -0,0 +1,106 @@
+(function () {
+    'use strict';
+
+    /**
+     * A component to render a table for the tracked references of an item
+     */
+
+    function umbTrackedReferencesTableController(editorService, udiParser, navigationService, overlayService)
+    {
+        var vm = this;
+
+        vm.changePageNumber = changePageNumber;
+        vm.getUrl = getUrl;
+        vm.referenceAnchorClicked = referenceAnchorClicked;
+
+        function changePageNumber(pageNumber) {
+            vm.onPageChanged({ 'pageNumber' : pageNumber });
+        }
+
+        function getUrl(itemUdi, itemId) {
+            // extract the entity type from the udi
+            var udi = udiParser.parse(itemUdi);
+
+            if (udi) {
+                var entityType = udi.entityType;
+
+                if(udi.entityType === "document") {
+                    entityType = "content";
+                }
+                return "#/" + entityType + "/" + entityType + "/edit/" + itemId;
+            }
+	          return "#";
+	    }
+
+        function close() {
+            navigationService.hideMenu(); // close menu
+            overlayService.close(); // close overlay
+        }
+
+        function referenceAnchorClicked($event, reference) {
+
+
+            if ($event.shiftKey || $event.ctrlKey || $event.metaKey) {
+                // we will let the browser take over here.
+                return;
+            }
+
+            $event.preventDefault();
+            close();
+
+            var editorModel = {
+                id: reference.id,
+                submit: function (model) {
+                    editorService.close();
+                },
+                close: function () {
+                    editorService.close();
+                }
+            };
+
+            overlayService.close();
+
+            // extract the entity type from the udi
+            var udi = udiParser.parse(reference.udi);
+
+            if (udi && udi.entityType === "document")
+            {
+                editorService.contentEditor(editorModel);
+                return;
+            }
+
+            if (udi && udi.entityType === "media")
+            {
+                editorService.mediaEditor(editorModel);
+                return;
+            }
+
+            if (udi && udi.entityType === "member")
+            {
+                editorModel.id = reference.key;
+                editorService.memberEditor(editorModel);
+                return;
+            }
+        }
+    }
+
+    var umbTrackedReferencesTableComponent = {
+        templateUrl: 'views/components/references/umb-tracked-references-table.html',
+        transclude: true,
+        bindings: {
+            pageNumber: "<",
+            totalPages: "<",
+            headline: "<",
+            items: "<",
+            showType: "<?",
+            showTypeName: "<?",
+            showRelationTypeName: "<?",
+            onPageChanged: "&"
+        },
+        controllerAs: 'vm',
+        controller: umbTrackedReferencesTableController
+    };
+
+    angular.module('umbraco.directives').component('umbTrackedReferencesTable', umbTrackedReferencesTableComponent);
+
+})();
diff --git a/src/Umbraco.Web.UI.Client/src/common/resources/media.resource.js b/src/Umbraco.Web.UI.Client/src/common/resources/media.resource.js
index 87ba05467523..d426dcd5162b 100644
--- a/src/Umbraco.Web.UI.Client/src/common/resources/media.resource.js
+++ b/src/Umbraco.Web.UI.Client/src/common/resources/media.resource.js
@@ -3,7 +3,7 @@
  * @name umbraco.resources.mediaResource
  * @description Loads in data for media
  **/
-function mediaResource($q, $http, umbDataFormatter, umbRequestHelper) {
+function mediaResource($q, $http, umbDataFormatter, umbRequestHelper, trackedReferencesResource) {
 
     /** internal method process the saving of data and post processing the result */
     function saveMediaItem(content, action, files) {
@@ -552,36 +552,41 @@ function mediaResource($q, $http, umbDataFormatter, umbRequestHelper) {
                 'Failed to retrieve media items for search: ' + query);
         },
 
+         /**
+         * @ngdoc method
+         * @name umbraco.resources.mediaResource#getPagedReferences
+         * @methodOf umbraco.resources.mediaResource
+         *
+         * @description
+         * Gets a page list of tracked references for the current item, so you can see where an item is being used
+         *
+         * @deprecated
+         * Use umbraco.resources.trackedReferencesResource#getPagedReferences instead
+         *
+         * ##usage
+         * <pre>
+         * var options = {
+         *      pageSize : 25,
+         *      pageNumber : 1,
+         *      entityType : 'DOCUMENT'
+         *  };
+         * trackedReferencesResource.getPagedReferences(1, options)
+         *    .then(function(data) {
+         *        console.log(data);
+         *    });
+         * </pre>
+         *
+         * @param {int} id Id of the item to query for tracked references
+         * @param {Object} args optional args object
+         * @param {Int} args.pageSize the pagesize of the returned list (default 25)
+         * @param {Int} args.pageNumber the current page index (default 1)
+         * @param {Int} args.entityType the type of tracked entity (default : DOCUMENT). Possible values DOCUMENT, MEDIA
+         * @returns {Promise} resourcePromise object.
+         *
+         */
         getPagedReferences: function (id, options) {
-
-            var defaults = {
-                pageSize: 25,
-                pageNumber: 1,
-                entityType: "DOCUMENT"
-            };
-            if (options === undefined) {
-                options = {};
-            }
-            //overwrite the defaults if there are any specified
-            Utilities.extend(defaults, options);
-            //now copy back to the options we will use
-            options = defaults;
-
-            return umbRequestHelper.resourcePromise(
-                $http.get(
-                    umbRequestHelper.getApiUrl(
-                        "mediaApiBaseUrl",
-                        "GetPagedReferences",
-                        {
-                            id: id,
-                            entityType: options.entityType,
-                            pageNumber: options.pageNumber,
-                            pageSize: options.pageSize
-                        }
-                    )),
-                "Failed to retrieve usages for media of id " + id);
+            return trackedReferencesResource.getPagedReferences(id, options);
         }
-
     };
 }
 
diff --git a/src/Umbraco.Web.UI.Client/src/common/resources/trackedreferences.resource.js b/src/Umbraco.Web.UI.Client/src/common/resources/trackedreferences.resource.js
new file mode 100644
index 000000000000..cd64c89589ec
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/common/resources/trackedreferences.resource.js
@@ -0,0 +1,178 @@
+/**
+ * @ngdoc service
+ * @name umbraco.resources.trackedReferencesResource
+ * @description Loads in data for tracked references
+ **/
+function trackedReferencesResource($q, $http, umbRequestHelper) {
+
+    return {
+
+        /**
+         * @ngdoc method
+         * @name umbraco.resources.trackedReferencesResource#getPagedReferences
+         * @methodOf umbraco.resources.trackedReferencesResource
+         *
+         * @description
+         * Gets a page list of tracked references for the current item, so you can see where an item is being used
+         *
+         * ##usage
+         * <pre>
+         * var options = {
+         *      pageSize : 25,
+         *      pageNumber : 1,
+         *      entityType : 'DOCUMENT'
+         *  };
+         * trackedReferencesResource.getPagedReferences(1, options)
+         *    .then(function(data) {
+         *        console.log(data);
+         *    });
+         * </pre>
+         *
+         * @param {int} id Id of the item to query for tracked references
+         * @param {Object} args optional args object
+         * @param {Int} args.pageSize the pagesize of the returned list (default 25)
+         * @param {Int} args.pageNumber the current page index (default 1)
+         * @param {String} args.entityType the type of tracked entity (default : DOCUMENT). Possible values DOCUMENT, MEDIA
+         * @returns {Promise} resourcePromise object.
+         *
+         */
+        getPagedReferences: function (id, args) {
+
+            var defaults = {
+                pageSize: 10,
+                pageNumber: 1,
+                entityType: "DOCUMENT"
+            };
+            if (args === undefined) {
+                args = {};
+            }
+
+            //overwrite the defaults if there are any specified
+            var options = Utilities.extend(defaults, args);
+
+            return umbRequestHelper.resourcePromise(
+                $http.get(
+                    umbRequestHelper.getApiUrl(
+                        "trackedReferencesApiBaseUrl",
+                        "GetPagedReferences",
+                        {
+                            id: id,
+                            entityType: options.entityType,
+                            pageNumber: options.pageNumber,
+                            pageSize: options.pageSize,
+                            filterMustBeIsDependency: options.filterMustBeIsDependency
+                        }
+                    )),
+                "Failed to retrieve usages for entity of id " + id);
+        },
+
+        /**
+         * @ngdoc method
+         * @name umbraco.resources.trackedReferencesResource#getPagedDescendantsInReferences
+         * @methodOf umbraco.resources.trackedReferencesResource
+         *
+         * @description
+         * Gets a page list of the child nodes of the current item used in any kind of relation
+         *
+         * ##usage
+         * <pre>
+         * var options = {
+         *      pageSize : 25,
+         *      pageNumber : 1,
+         *      entityType : 'DOCUMENT'
+         *  };
+         * trackedReferencesResource.getPagedDescendantsInReferences(1, options)
+         *    .then(function(data) {
+         *        console.log(data);
+         *    });
+         * </pre>
+         *
+         * @param {int} id Id of the item to query for child nodes used in relation
+         * @param {Object} args optional args object
+         * @param {Int} args.pageSize the pagesize of the returned list (default 25)
+         * @param {Int} args.pageNumber the current page index (default 1)
+         * @param {String} args.entityType the type of tracked entity (default : DOCUMENT). Possible values DOCUMENT, MEDIA
+         * @returns {Promise} resourcePromise object.
+         *
+         */
+        getPagedDescendantsInReferences: function (id, args) {
+
+            var defaults = {
+                pageSize: 10,
+                pageNumber: 1,
+                entityType: "DOCUMENT"
+            };
+            if (args === undefined) {
+                args = {};
+            }
+
+            //overwrite the defaults if there are any specified
+            var options = Utilities.extend(defaults, args);
+
+            return umbRequestHelper.resourcePromise(
+                $http.get(
+                    umbRequestHelper.getApiUrl(
+                        "trackedReferencesApiBaseUrl",
+                        "GetPagedDescendantsInReferences",
+                        {
+                            parentId: id,
+                            entityType: options.entityType,
+                            pageNumber: options.pageNumber,
+                            pageSize: options.pageSize
+                        }
+                    )),
+                "Failed to retrieve usages for descendants of parent with id " + id);
+        },
+
+        /**
+         * @ngdoc method
+         * @name umbraco.resources.trackedReferencesResource#getPagedReferencedItems
+         * @methodOf umbraco.resources.trackedReferencesResource
+         *
+         * @description
+         * Checks if any of the items are used in a relation and returns a page list, so you can see which items are being used
+         *
+         * ##usage
+         * <pre>
+         * var ids = [123,3453,2334,2343];
+         * var options = {
+         *      pageSize : 25,
+         *      pageNumber : 1,
+         *      entityType : 'DOCUMENT'
+         *  };
+         *
+         * trackedReferencesResource.getPagedReferencedItems(ids, options)
+         *    .then(function(data) {
+         *        console.log(data);
+         *    });
+         * </pre>
+         *
+         * @param {Array} ids array of the selected items ids to query for references
+         * @param {Object} options optional options object
+         * @param {Int} options.pageSize the pagesize of the returned list (default 25)
+         * @param {Int} options.pageNumber the current page index (default 1)
+         * @param {String} options.entityType the type of tracked entity (default : DOCUMENT). Possible values DOCUMENT, MEDIA
+         * @returns {Promise} resourcePromise object.
+         *
+         */
+        getPagedReferencedItems: function (ids, options) {
+            var query = `entityType=${options.entityType}&pageNumber=${options.pageNumber}&pageSize=${options.pageSize}`;
+
+            return umbRequestHelper.resourcePromise(
+                $http.post(
+                    umbRequestHelper.getApiUrl(
+                        "trackedReferencesApiBaseUrl",
+                        "getPagedReferencedItems",
+                        query),
+                        {
+                            ids: ids,
+                            entityType: options.entityType,
+                            pageNumber: options.pageNumber,
+                            pageSize: options.pageSize
+                        }),
+                "Failed to check for references of nodes with ids " + ids);
+        }
+    }
+}
+
+angular.module('umbraco.resources').factory('trackedReferencesResource', trackedReferencesResource);
diff --git a/src/Umbraco.Web.UI.Client/src/common/services/umbdataformatter.service.js b/src/Umbraco.Web.UI.Client/src/common/services/umbdataformatter.service.js
index a8f62dca4b6d..38b56b766110 100644
--- a/src/Umbraco.Web.UI.Client/src/common/services/umbdataformatter.service.js
+++ b/src/Umbraco.Web.UI.Client/src/common/services/umbdataformatter.service.js
@@ -461,6 +461,7 @@
                     alias: relationType.alias,
                     key: relationType.key,
                     isBidirectional: relationType.isBidirectional,
+                    isDependency: relationType.isDependency,
                     parentObjectType: relationType.parentObjectType,
                     childObjectType: relationType.childObjectType
                 };
diff --git a/src/Umbraco.Web.UI.Client/src/less/components/overlays.less b/src/Umbraco.Web.UI.Client/src/less/components/overlays.less
index 12cce286d6d7..60020066c0e1 100644
--- a/src/Umbraco.Web.UI.Client/src/less/components/overlays.less
+++ b/src/Umbraco.Web.UI.Client/src/less/components/overlays.less
@@ -10,6 +10,10 @@
     .scoped-view{
         display: none;
     }
+
+    .abstract {
+        margin-bottom : 20px;
+    }
 }
 
 .umb-overlay__form {
@@ -51,7 +55,7 @@
 }
 
 .umb-overlay__title {
-    font-size: 16px;
+    font-size: 20px;
     color: @black;
     line-height: 16px;
     font-weight: bold;
diff --git a/src/Umbraco.Web.UI.Client/src/less/components/umb-table.less b/src/Umbraco.Web.UI.Client/src/less/components/umb-table.less
index 6c1e5058d267..73ef47133caa 100644
--- a/src/Umbraco.Web.UI.Client/src/less/components/umb-table.less
+++ b/src/Umbraco.Web.UI.Client/src/less/components/umb-table.less
@@ -162,6 +162,7 @@ input.umb-table__input {
     font-size: 14px;
     font-weight: bold;
     text-decoration: none;
+    cursor: pointer;
 
     &:hover {
         color: @ui-option-type-hover;
diff --git a/src/Umbraco.Web.UI.Client/src/views/components/content/umb-content-node-info.html b/src/Umbraco.Web.UI.Client/src/views/components/content/umb-content-node-info.html
index 381880da2ee7..6429e39db629 100644
--- a/src/Umbraco.Web.UI.Client/src/views/components/content/umb-content-node-info.html
+++ b/src/Umbraco.Web.UI.Client/src/views/components/content/umb-content-node-info.html
@@ -20,6 +20,9 @@
                 </ul>
             </umb-box-content>
         </umb-box>
+
+        <umb-tracked-references id="node.id"></umb-tracked-references>
+
         <umb-box data-element="node-info-redirects" ng-cloak ng-show="!urlTrackerDisabled && hasRedirects">
             <umb-box-header title-key="redirectUrls_redirectUrlManagement"></umb-box-header>
             <umb-box-content class="block-form">
diff --git a/src/Umbraco.Web.UI.Client/src/views/components/media/umb-media-node-info.html b/src/Umbraco.Web.UI.Client/src/views/components/media/umb-media-node-info.html
index 1e72950410f2..010102b920af 100644
--- a/src/Umbraco.Web.UI.Client/src/views/components/media/umb-media-node-info.html
+++ b/src/Umbraco.Web.UI.Client/src/views/components/media/umb-media-node-info.html
@@ -3,7 +3,7 @@
     <umb-load-indicator ng-if="loading === true"></umb-load-indicator>
 
     <!-- Main Column -->
-    <div class="umb-package-details__main-content" ng-if="loading === false">
+    <div class="umb-package-details__main-content">
 
         <!-- Links -->
         <umb-box data-element="node-info-urls" class="mb4">
@@ -27,131 +27,11 @@
             </umb-box-content>
         </umb-box>
 
-        <!-- Media Tracking (NO Items) -->
-        <umb-box ng-if="(hasContentReferences === false) && (hasMediaReferences === false) && (hasMemberReferences === false) && loading === false">
-            <umb-box-header title-key="references_tabName"></umb-box-header>
-            <umb-box-content>
-                <umb-empty-state size="small">
-                    This Media item has no references.
-                </umb-empty-state>
-            </umb-box-content>
-        </umb-box>
-
-        <!-- Media Tracking (With Items) -->
-        <div ng-if="loading === false">
-            <!-- Content -->
-            <div ng-if="contentReferences.items.length > 0">
-
-                <h5 class="mt0" style="margin-bottom: 20px;">
-                    <localize key="references_labelUsedByDocuments">Used in Documents</localize>
-                </h5>
-
-                <div class="umb-table">
-                    <div class="umb-table-head">
-                        <div class="umb-table-row">
-                            <div class="umb-table-cell"></div>
-                            <div class="umb-table-cell umb-table__name not-fixed"><localize key="general_name">Name</localize></div>
-                            <div class="umb-table-cell"><localize key="content_alias">Alias</localize></div>
-                            <div class="umb-table-cell umb-table-cell--nano"><localize key="general_open" style="visibility:hidden;">Open</localize></div>
-                        </div>
-                    </div>
-                    <div class="umb-table-body">
-                        <div class="umb-table-row" ng-repeat="reference in contentReferences.items">
-                            <div class="umb-table-cell"><umb-icon icon="{{reference.icon}}" class="umb-table-body__icon"></umb-icon></div>
-                            <div class="umb-table-cell umb-table__name"><span>{{::reference.name}}</span></div>
-                            <div class="umb-table-cell"><span title="{{::reference.alias}}">{{::reference.alias}}</span></div>
-                            <div class="umb-table-cell umb-table-cell--nano"><a ng-href="#/content/content/edit/{{::reference.id}}"><localize key="general_open">Open</localize></a></div>
-                        </div>
-                    </div>
-                </div>
-
-                <!-- Pagination -->
-                <div class="flex justify-center">
-                    <umb-pagination ng-if="contentReferences.totalPages"
-                                    page-number="contentReferences.pageNumber"
-                                    total-pages="contentReferences.totalPages"
-                                    on-change="changeContentPageNumber(pageNumber)">
-                    </umb-pagination>
-                </div>
-            </div>
-
-            <!-- Members -->
-            <div ng-if="memberReferences.items.length > 0">
-
-                <h5 class="mt0" style="margin-bottom: 20px;">
-                    <localize key="references_labelUsedByMembers">Used in Members</localize>
-                </h5>
-
-                <div class="umb-table">
-                    <div class="umb-table-head">
-                        <div class="umb-table-row">
-                            <div class="umb-table-cell"></div>
-                            <div class="umb-table-cell umb-table__name not-fixed"><localize key="general_name">Name</localize></div>
-                            <div class="umb-table-cell"><localize key="content_alias">Alias</localize></div>
-                            <div class="umb-table-cell umb-table-cell--nano"><localize key="general_open" style="visibility:hidden;">Open</localize></div>
-                        </div>
-                    </div>
-                    <div class="umb-table-body">
-                        <div class="umb-table-row" ng-repeat="reference in memberReferences.items">
-                            <div class="umb-table-cell"><umb-icon icon="{{reference.icon}}" class="umb-table-body__icon"></umb-icon></div>
-                            <div class="umb-table-cell umb-table__name"><span>{{::reference.name}}</span></div>
-                            <div class="umb-table-cell"><span title="{{::reference.alias}}">{{::reference.alias}}</span></div>
-                            <div class="umb-table-cell umb-table-cell--nano"><a href="#/member/member/edit/{{::reference.key}}"><localize key="general_open">Open</localize></a></div>
-                        </div>
-                    </div>
-                </div>
-
-                <!-- Pagination -->
-                <div class="flex justify-center">
-                    <umb-pagination ng-if="memberReferences.totalPages"
-                                    page-number="memberReferences.pageNumber"
-                                    total-pages="memberReferences.totalPages"
-                                    on-change="changeMemberPageNumber(pageNumber)">
-                    </umb-pagination>
-                </div>
-            </div>
-
-            <!-- Media -->
-            <div ng-if="mediaReferences.items.length > 0">
-
-                <h5 class="mt0" style="margin-bottom: 20px;">
-                    <localize key="references_labelUsedByMedia">Used in Media</localize>
-                </h5>
-
-                <div class="umb-table">
-                    <div class="umb-table-head">
-                        <div class="umb-table-row">
-                            <div class="umb-table-cell"></div>
-                            <div class="umb-table-cell umb-table__name not-fixed"><localize key="general_name">Name</localize></div>
-                            <div class="umb-table-cell"><localize key="content_alias">Alias</localize></div>
-                            <div class="umb-table-cell umb-table-cell--nano"><localize key="general_open" style="visibility:hidden;">Open</localize></div>
-                        </div>
-                    </div>
-                    <div class="umb-table-body">
-                        <div class="umb-table-row" ng-repeat="reference in mediaReferences.items">
-                            <div class="umb-table-cell"><umb-icon icon="{{reference.icon}}" class="umb-table-body__icon"></umb-icon></div>
-                            <div class="umb-table-cell umb-table__name"><span>{{::reference.name}}</span></div>
-                            <div class="umb-table-cell"><span title="{{::reference.alias}}">{{::reference.alias}}</span></div>
-                            <div class="umb-table-cell umb-table-cell--nano"><a href="#/media/media/edit/{{::reference.id}}"><localize key="general_open">Open</localize></a></div>
-                        </div>
-                    </div>
-                </div>
-
-                <!-- Pagination -->
-                <div class="flex justify-center">
-                    <umb-pagination ng-if="mediaReferences.totalPages"
-                                    page-number="mediaReferences.pageNumber"
-                                    total-pages="mediaReferences.totalPages"
-                                    on-change="changeMediaPageNumber(pageNumber)">
-                    </umb-pagination>
-                </div>
-            </div>
-
-        </div>
+        <umb-tracked-references id="node.id"></umb-tracked-references>
     </div>
 
     <!-- Sidebar -->
-    <div class="umb-package-details__sidebar" ng-if="loading === false">
+    <div class="umb-package-details__sidebar">
         <!-- General Info -->
         <umb-box data-element="node-info-general">
             <umb-box-header title-key="general_general"></umb-box-header>
diff --git a/src/Umbraco.Web.UI.Client/src/views/components/references/umb-tracked-references-bulk-action.html b/src/Umbraco.Web.UI.Client/src/views/components/references/umb-tracked-references-bulk-action.html
new file mode 100644
index 000000000000..8d3c36f19624
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/views/components/references/umb-tracked-references-bulk-action.html
@@ -0,0 +1,13 @@
+<umb-load-indicator ng-if="vm.loading === true"></umb-load-indicator>
+
+<div ng-if="vm.loading === false">
+    
+    <div ng-if="vm.hasReferences">
+        <umb-tracked-references-table items="vm.referencedItems.items"
+                                      total-pages="vm.referencedItems.totalPages"
+                                      page-number="vm.referencedItems.pageNumber"
+                                      headline="vm.referencedItemsTitle"
+                                      on-page-changed="vm.changeReferencesPageNumber(pageNumber)">
+        </umb-tracked-references-table>
+    </div>
+</div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/components/references/umb-tracked-references-table.html b/src/Umbraco.Web.UI.Client/src/views/components/references/umb-tracked-references-table.html
new file mode 100644
index 000000000000..afc8f9a3e667
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/views/components/references/umb-tracked-references-table.html
@@ -0,0 +1,35 @@
+<div>
+    <h5 class="mt0" style="margin-bottom: 20px;">
+        {{vm.headline}}
+    </h5>
+
+    <div class="umb-table">
+        <div class="umb-table-head">
+            <div class="umb-table-row">
+                <div class="umb-table-cell"></div>
+                <div class="umb-table-cell umb-table__name not-fixed"><localize key="general_nodename">Node Name</localize></div>
+                <div ng-if="vm.showTypeName" class="umb-table-cell"><localize key="general_typename">Type Name</localize></div>
+                <div ng-if="vm.showType" class="umb-table-cell"><localize key="general_type">Type</localize></div>
+                <div ng-if="vm.showRelationTypeName" class="umb-table-cell"><localize key="relationType_relation">Relation</localize></div>
+            </div>
+        </div>
+        <div class="umb-table-body">
+            <div class="umb-table-row" ng-repeat="reference in vm.items">
+                <div class="umb-table-cell"><i class="umb-table-body__icon {{reference.icon}}"></i></div>
+                <div class="umb-table-cell umb-table__name"><a ng-href="{{vm.getUrl(reference.udi, reference.id)}}" ng-click="vm.referenceAnchorClicked($event, reference)">{{::reference.name}}</a></div>
+                <div ng-if="vm.showTypeName" class="umb-table-cell"><span title="{{::reference.contentTypeName}}">{{::reference.contentTypeName}}</span></div>
+                <div ng-if="vm.showType" class="umb-table-cell"><span title="{{::reference.type}}">{{::reference.type}}</span></div>
+                <div ng-if="vm.showRelationTypeName" class="umb-table-cell"><span title="{{::reference.relationTypeName}}">{{::reference.relationTypeName}}</span></div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Pagination -->
+    <div class="flex justify-center">
+        <umb-pagination ng-if="vm.totalPages"
+                        page-number="vm.pageNumber"
+                        total-pages="vm.totalPages"
+                        on-change="vm.changePageNumber(pageNumber)">
+        </umb-pagination>
+    </div>
+</div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/components/references/umb-tracked-references.html b/src/Umbraco.Web.UI.Client/src/views/components/references/umb-tracked-references.html
new file mode 100644
index 000000000000..fd788cc598f8
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/views/components/references/umb-tracked-references.html
@@ -0,0 +1,36 @@
+<umb-load-indicator ng-if="vm.loading === true"></umb-load-indicator>
+
+<umb-box ng-if="(vm.hasContentReferences === false) && (vm.hasContentReferencesInDescendants === false) && (vm.hasMediaReferences === false) && (vm.hasMediaReferencesInDescendants === false) && (vm.hasMemberReferences === false) && (vm.loading === false) && (vm.hideNoResult === false)">
+    <umb-box-header title-key="references_tabName"></umb-box-header>
+    <umb-box-content>
+        <umb-empty-state size="small">
+            <localize key="references_itemHasNoReferences">This item is not referenced</localize>
+        </umb-empty-state>
+    </umb-box-content>
+</umb-box>
+
+<div ng-if="vm.loading === false">
+
+    <!-- Combined list -->
+    <div ng-if="vm.hasReferences">
+        <umb-tracked-references-table items="vm.references.items"
+                                      total-pages="vm.references.totalPages"
+                                      page-number="vm.references.pageNumber"
+                                      headline="vm.referencesTitle"
+                                      on-page-changed="vm.changeReferencesPageNumber(pageNumber)"
+                                      show-type-name="true"
+                                      show-type="!vm.compact"
+                                      show-relation-type-name="!vm.compact"
+                                      type-label-key="content_documentType">
+        </umb-tracked-references-table>
+    </div>
+
+    <div ng-if="vm.hasReferencesInDescendants">
+        <umb-tracked-references-table  items="vm.referencedDescendants.items"
+                                                total-pages="vm.referencedDescendants.totalPages"
+                                                page-number="vm.referencedDescendants.pageNumber"
+                                                headline="vm.referencedDescendantsTitle"
+                                                on-page-changed="vm.changeDescendantsPageNumber(pageNumber)">
+        </umb-tracked-references-table>
+    </div>
+</div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js b/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js
index 060c0ec7d9d2..771d1b928058 100644
--- a/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js
@@ -6,7 +6,7 @@
  * @description
  * The controller for deleting content
  */
-function ContentDeleteController($scope, $timeout, contentResource, treeService, navigationService, editorState, $location, overlayService, languageResource) {
+function ContentDeleteController($scope, $timeout, contentResource, treeService, navigationService, editorState, $location, overlayService, languageResource, localizationService) {
 
     /**
      * Used to toggle UI elements during delete operations
@@ -16,6 +16,10 @@ function ContentDeleteController($scope, $timeout, contentResource, treeService,
         $scope.currentNode.loading = isDeleting;
         $scope.busy = isDeleting;
     }
+
+    $scope.checkingReferences = true;
+    $scope.warningText = null;
+    $scope.disableDelete = false;
     
     $scope.performDelete = function() {
 
@@ -77,6 +81,27 @@ function ContentDeleteController($scope, $timeout, contentResource, treeService,
 
     };
 
+    $scope.checkingReferencesComplete = () => {
+        $scope.checkingReferences = false;
+    };
+
+    $scope.onReferencesWarning = () => {
+        // check if the deletion of items that have references has been disabled
+        if (Umbraco.Sys.ServerVariables.umbracoSettings.disableDeleteWhenReferenced) {
+            // this will only be set to true if we have a warning, indicating that this item or its descendants have reference
+            $scope.disableDelete = true;
+
+            localizationService.localize("references_deleteDisabledWarning").then((value) => {
+                $scope.warningText = value;
+            });
+        }
+        else {
+            localizationService.localize("references_deleteWarning").then((value) => {
+                $scope.warningText = value;
+            });
+        }
+    };
+
     $scope.cancel = function() {
         toggleDeleting(false);
         $scope.close();
diff --git a/src/Umbraco.Web.UI.Client/src/views/content/delete.html b/src/Umbraco.Web.UI.Client/src/views/content/delete.html
index 316d0669c4b5..765dbda5319d 100644
--- a/src/Umbraco.Web.UI.Client/src/views/content/delete.html
+++ b/src/Umbraco.Web.UI.Client/src/views/content/delete.html
@@ -1,7 +1,7 @@
-<div class="umb-dialog umb-pane" ng-controller="Umbraco.Editors.Content.DeleteController">
-    <div class="umb-dialog-body" auto-scale="90">
+<div class="umb-dialog" ng-controller="Umbraco.Editors.Content.DeleteController">
+    <div class="umb-dialog-body">
 
-        <div ng-show="success">
+        <div ng-show="success" class="umb-pane">
             <div class="alert alert-success">
                 <strong>{{currentNode.name}}</strong>
                 <localize key="actions_wasDeleted">was deleted</localize>
@@ -9,20 +9,28 @@
             <button class="btn btn-primary" ng-click="close()">Ok</button>
         </div>
 
-        <div ng-hide="success">
-            <p class="abstract">
+        <div ng-hide="success" class="umb-pane">
+            <p class="abstract" ng-if="!disableDelete">
                 <localize key="defaultdialogs_confirmdelete">Are you sure you want to delete</localize> <strong>{{currentNode.name}}</strong>?
             </p>
 
-            <div class="umb-alert umb-alert--warning" ng-show="currentNode.metaData.variesByCulture && !currentNode.trashed">
+            <div class="abstract umb-alert umb-alert--warning" ng-show="currentNode.metaData.variesByCulture && !currentNode.trashed">
                 <localize key="defaultdialogs_variantdeletewarning">This will delete the node and all its languages. If you only want to delete one language go and unpublish it instead.</localize>
             </div>
 
+            <umb-tracked-references id="currentNode.id" on-loading-complete="checkingReferencesComplete()" hide-no-result="true" compact="true" show-descendants="true" hide-none-dependencies="true" on-warning="onReferencesWarning()"></umb-tracked-references>
+
+            <div class="abstract umb-alert umb-alert--warning" ng-if="warningText">
+                {{warningText}}
+            </div>
+
             <div class="umb-alert umb-alert--warning" ng-show="currentNode.trashed">
                 <localize key="defaultdialogs_recycleBinWarning">When items are deleted from the recycle bin, they will be gone forever</localize>.
             </div>
 
-            <umb-confirm on-confirm="performDelete" confirm-button-style="danger" on-cancel="cancel"></umb-confirm>
+            <umb-confirm ng-if="!disableDelete" on-confirm="performDelete" confirm-button-style="danger" on-cancel="cancel" ng-hide="checkingReferences"></umb-confirm>
+
+            <umb-confirm ng-if="disableDelete" confirm-button-style="danger" on-cancel="cancel"></umb-confirm>
         </div>
 
     </div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/content/overlays/unpublish.controller.js b/src/Umbraco.Web.UI.Client/src/views/content/overlays/unpublish.controller.js
index 936ab3b1049e..f6c0ea67f9e3 100644
--- a/src/Umbraco.Web.UI.Client/src/views/content/overlays/unpublish.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/content/overlays/unpublish.controller.js
@@ -6,10 +6,13 @@
         var vm = this;
         var autoSelectedVariants = [];
 
+        vm.id = $scope.content.id;
+        vm.warningText = null;
         vm.changeSelection = changeSelection;
 
         function onInit() {
 
+            $scope.model.hideSubmitButton = true;
             vm.variants = $scope.model.variants;
             vm.unpublishableVariants = vm.variants.filter(publishedVariantFilter)
 
@@ -108,6 +111,24 @@
             });
         });
 
+        vm.checkingReferencesComplete = () => {
+            $scope.model.hideSubmitButton = false;
+        };
+
+        vm.onReferencesWarning = () => {
+            $scope.model.submitButtonStyle = "danger";
+
+            // check if the unpublishing of items that have references has been disabled
+            if (Umbraco.Sys.ServerVariables.umbracoSettings.disableUnpublishWhenReferenced) {
+                // this will only be disabled if we have a warning, indicating that this item or its descendants have reference
+                $scope.model.disableSubmitButton = true;
+            }
+
+            localizationService.localize("references_unpublishWarning").then((value) => {
+                vm.warningText = value;
+            });
+        };
+
         onInit();
 
     }
diff --git a/src/Umbraco.Web.UI.Client/src/views/content/overlays/unpublish.html b/src/Umbraco.Web.UI.Client/src/views/content/overlays/unpublish.html
index a994fe38ed72..b938065bc2f0 100644
--- a/src/Umbraco.Web.UI.Client/src/views/content/overlays/unpublish.html
+++ b/src/Umbraco.Web.UI.Client/src/views/content/overlays/unpublish.html
@@ -49,7 +49,14 @@
                     </div>
                 </ng-form>
             </div>
-            <br />
         </div>
     </div>
+
+    <div style="margin-top: 15px;">
+        <umb-tracked-references id="vm.id" on-loading-complete="vm.checkingReferencesComplete()" hide-no-result="true" compact="true" show-descendants="true" hide-none-dependencies="true" on-warning="vm.onReferencesWarning()"></umb-tracked-references>
+    </div>
+
+    <div class="abstract umb-alert umb-alert--warning" ng-if="vm.warningText">
+        {{vm.warningText}}
+    </div>
 </div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/media/delete.html b/src/Umbraco.Web.UI.Client/src/views/media/delete.html
index 7231ccf2c4fb..894cf5ef7734 100644
--- a/src/Umbraco.Web.UI.Client/src/views/media/delete.html
+++ b/src/Umbraco.Web.UI.Client/src/views/media/delete.html
@@ -10,15 +10,23 @@
         </div>
 
         <div ng-hide="success">
-            <p class="abstract">
+            <p class="abstract" ng-if="!disableDelete">
                 <localize key="defaultdialogs_confirmdelete">Are you sure you want to delete</localize> <strong>{{currentNode.name}}</strong>?
             </p>
 
+            <umb-tracked-references id="currentNode.id" on-loading-complete="checkingReferencesComplete()" hide-no-result="true" compact="true" show-descendants="true" hide-none-dependencies="true" on-warning="onReferencesWarning()"></umb-tracked-references>
+
+            <div class="abstract umb-alert umb-alert--warning" ng-if="warningText">
+                {{warningText}}
+            </div>
+
             <div class="umb-alert umb-alert--warning" ng-show="currentNode.trashed">
                 <localize key="defaultdialogs_recycleBinWarning">When items are deleted from the recycle bin, they will be gone forever</localize>.
             </div>
 
-            <umb-confirm on-confirm="performDelete" on-cancel="close" confirm-button-style="danger"></umb-confirm>
+            <umb-confirm ng-if="!disableDelete" on-confirm="performDelete" confirm-button-style="danger" on-cancel="close" ng-hide="checkingReferences"></umb-confirm>
+
+            <umb-confirm ng-if="disableDelete" confirm-button-style="danger" on-cancel="close"></umb-confirm>
         </div>
 
     </div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js b/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js
index 879257137752..0761504b6bd8 100644
--- a/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js
@@ -6,7 +6,11 @@
  * @description
  * The controller for deleting content
  */
-function MediaDeleteController($scope, mediaResource, treeService, navigationService, editorState, $location, overlayService) {
+function MediaDeleteController($scope, mediaResource, treeService, navigationService, editorState, $location, overlayService, localizationService) {
+
+    $scope.checkingReferences = true;
+    $scope.warningText = null;
+    $scope.disableDelete = false;
 
     $scope.performDelete = function() {
 
@@ -26,7 +30,7 @@ function MediaDeleteController($scope, mediaResource, treeService, navigationSer
             treeService.removeNode($scope.currentNode);
 
             if (rootNode) {
-                //ensure the recycle bin has child nodes now            
+                //ensure the recycle bin has child nodes now
                 var recycleBin = treeService.getDescendantNode(rootNode, -21);
                 if (recycleBin) {
                     recycleBin.hasChildren = true;
@@ -65,6 +69,27 @@ function MediaDeleteController($scope, mediaResource, treeService, navigationSer
         });
     };
 
+    $scope.checkingReferencesComplete = () => {
+        $scope.checkingReferences = false;
+    };
+
+    $scope.onReferencesWarning = () => {
+        // check if the deletion of items that have references has been disabled
+        if (Umbraco.Sys.ServerVariables.umbracoSettings.disableDeleteWhenReferenced) {
+            // this will only be set to true if we have a warning, indicating that this item or its descendants have reference
+            $scope.disableDelete = true;
+
+            localizationService.localize("references_deleteDisabledWarning").then((value) => {
+                $scope.warningText = value;
+            });
+        }
+        else {
+            localizationService.localize("references_deleteWarning").then((value) => {
+                $scope.warningText = value;
+            });
+        }
+    };
+
     $scope.close = function() {
         navigationService.hideDialog();
     };
diff --git a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/listview.controller.js b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/listview.controller.js
index c66ff1a46171..791158a890ab 100644
--- a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/listview.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/listview.controller.js
@@ -386,6 +386,7 @@ function listViewController($scope, $interpolate, $routeParams, $injector, $time
             view: "views/propertyeditors/listview/overlays/delete.html",
             deletesVariants: selectionHasVariants(),
             isTrashed: $scope.isTrashed,
+            selection: $scope.selection,
             submitButtonLabelKey: "contentTypeEditor_yesDelete",
             submitButtonStyle: "danger",
             submit: function (model) {
@@ -495,8 +496,8 @@ function listViewController($scope, $interpolate, $routeParams, $injector, $time
             view: "views/propertyeditors/listview/overlays/listviewunpublish.html",
             submitButtonLabelKey: "actions_unpublish",
             submitButtonStyle: "warning",
+            selection: $scope.selection,
             submit: function (model) {
-
                 // create a comma separated array of selected cultures
                 let selectedCultures = [];
                 if (model.languages && model.languages.length > 0) {
@@ -506,7 +507,6 @@ function listViewController($scope, $interpolate, $routeParams, $injector, $time
                         }
                     });
                 }
-
                 performUnpublish(selectedCultures);
                 overlayService.close();
             },
diff --git a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/delete.controller.js b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/delete.controller.js
new file mode 100644
index 000000000000..85c8b8262080
--- /dev/null
+++ b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/delete.controller.js
@@ -0,0 +1,40 @@
+(function () {
+    "use strict";
+
+    function ListViewDeleteController($scope, localizationService) {
+
+        var vm = this;
+        vm.loading = true;
+        vm.disableDelete = false;
+
+        function onInit() {
+            $scope.model.hideSubmitButton = true;
+        }
+
+        vm.checkingReferencesComplete = () => {
+            $scope.model.hideSubmitButton = false;
+        };
+
+        vm.onReferencesWarning = () => {
+            $scope.model.submitButtonStyle = "danger";
+
+            // check if the deletion of items that have references has been disabled
+            if (Umbraco.Sys.ServerVariables.umbracoSettings.disableDeleteWhenReferenced) {
+                // this will only be set to true if we have a warning, indicating that this item or its descendants have reference
+                vm.disableDelete = true;
+                $scope.model.disableSubmitButton = true;
+            }
+
+            localizationService.localize("general_delete").then(function (action) {
+              localizationService.localize("references_listViewDialogWarning", [action.toLowerCase()]).then((value) => {
+                    vm.warningText = value;
+                });
+            });
+        };
+
+        onInit();
+    }
+
+    angular.module("umbraco").controller("Umbraco.Overlays.ListViewDeleteController", ListViewDeleteController);
+
+})();
diff --git a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/delete.html b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/delete.html
index f8b2b008d3fa..b137c74260b9 100644
--- a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/delete.html
+++ b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/delete.html
@@ -1,9 +1,15 @@
-<div>
+<div ng-controller="Umbraco.Overlays.ListViewDeleteController as vm">
 
-    <p class="abstract">
+    <p class="abstract" ng-if="!vm.disableDelete">
         <localize key="defaultdialogs_confirmdeleteNumberOfItems" tokens="[model.numberOfItems, model.totalItems]">Are you sure you want to delete</localize>?
     </p>
 
+    <umb-tracked-references-bulk-action selection="model.selection" on-loading-complete="vm.checkingReferencesComplete()" hide-no-result="true" compact="true" on-warning="vm.onReferencesWarning()"></umb-tracked-references-listview>
+
+    <div class="abstract umb-alert umb-alert--warning" ng-if="vm.warningText">
+        {{vm.warningText}}
+    </div>
+
     <div class="umb-alert umb-alert--warning" ng-show="model.deletesVariants && !model.isTrashed">
         <localize key="defaultdialogs_variantdeletewarning">This will delete the node and all its languages. If you only want to delete one language go and unpublish it instead.</localize>
     </div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/listviewunpublish.controller.js b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/listviewunpublish.controller.js
index 650b1b8438a7..cf432c031876 100644
--- a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/listviewunpublish.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/listviewunpublish.controller.js
@@ -5,6 +5,7 @@
 
         var vm = this;
         vm.loading = true;
+        vm.warningText = null;
 
         vm.changeSelection = changeSelection;
         
@@ -29,7 +30,9 @@
 
         function onInit() {
 
+            vm.selection = $scope.model.selection;
             vm.languages = $scope.model.languages;
+            $scope.model.hideSubmitButton = true;
 
             if (!$scope.model.title) {
                 localizationService.localize("content_unpublish").then(function (value) {
@@ -65,6 +68,26 @@
             vm.loading = false;
         }
 
+        vm.checkingReferencesComplete = () => {
+            $scope.model.hideSubmitButton = false;
+        };
+
+        vm.onReferencesWarning = () => {
+            $scope.model.submitButtonStyle = "danger";
+          
+            // check if the unpublishing of items that have references has been disabled
+            if (Umbraco.Sys.ServerVariables.umbracoSettings.disableUnpublishWhenReferenced) {
+                // this will only be disabled if we have a warning, indicating that this item or its descendants have reference
+                $scope.model.disableSubmitButton = true;
+            }
+
+            localizationService.localize("content_unpublish").then(function (action) {
+                localizationService.localize("references_listViewDialogWarning", [action.toLowerCase()]).then((value) => {
+                    vm.warningText = value;
+                });
+            });
+        };
+
         onInit();
 
         //when this dialog is closed, reset all 'publish' flags
diff --git a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/listviewunpublish.html b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/listviewunpublish.html
index 9a6af50f3e6c..2d255cbb2566 100644
--- a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/listviewunpublish.html
+++ b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/overlays/listviewunpublish.html
@@ -5,6 +5,14 @@
             <p><localize key="prompt_confirmListViewUnpublish">Unpublishing will remove the selected items and all their descendants from the site.</localize></p>
         </div>
 
+        <div style="margin-top: 15px;">
+            <umb-tracked-references-bulk-action selection="vm.selection" on-loading-complete="vm.checkingReferencesComplete()" hide-no-result="true" compact="true" on-warning="vm.onReferencesWarning()"></umb-tracked-references-listview>
+        </div>
+
+        <div class="abstract umb-alert umb-alert--warning" ng-if="vm.warningText">
+            {{vm.warningText}}
+        </div>
+
         <div ng-if="vm.loading" style="min-height: 50px; position: relative;">
                 <umb-load-indicator></umb-load-indicator>
         </div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/relationTypes/create.html b/src/Umbraco.Web.UI.Client/src/views/relationTypes/create.html
index 4e4711cc09fe..e910dd31ce0d 100644
--- a/src/Umbraco.Web.UI.Client/src/views/relationTypes/create.html
+++ b/src/Umbraco.Web.UI.Client/src/views/relationTypes/create.html
@@ -55,6 +55,34 @@
             <option ng-repeat="objectType in vm.objectTypes" value="{{objectType.id}}">{{objectType.name}}</option>
           </select>
         </umb-control-group>
+
+        <!-- IsDependency -->
+
+        <umb-control-group label="@relationType_isDependency">
+          <p class="sr-only" tabindex="0">
+            <localize key="relationType_direction"></localize>
+          </p>
+          <ul class="unstyled">
+            <li>
+              <label class="radio" for="dependency">
+                <umb-radiobutton input-id="dependency"
+                                 label-key="relationType_dependency"
+                                 model="vm.relationType.isDependency" name="relationType-isdependency" required="true"
+                                 value="true">
+                </umb-radiobutton>
+              </label>
+            </li>
+            <li>
+              <label class="radio" for="nodependency">
+                <umb-radiobutton input-id="nodependency"
+                                 label-key="relationType_noDependency"
+                                 model="vm.relationType.isDependency" name="relationType-isdependency" required="true"
+                                 value="false">
+                </umb-radiobutton>
+              </label>
+            </li>
+          </ul>
+        </umb-control-group>
       </div>
     </div>
     <div class="umb-dialog-footer btn-toolbar umb-btn-toolbar">
diff --git a/src/Umbraco.Web.UI.Client/src/views/relationTypes/edit.controller.js b/src/Umbraco.Web.UI.Client/src/views/relationTypes/edit.controller.js
index 62117728d035..1f0c054257ed 100644
--- a/src/Umbraco.Web.UI.Client/src/views/relationTypes/edit.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/relationTypes/edit.controller.js
@@ -74,7 +74,7 @@ function RelationTypeEditController($scope, $routeParams, relationTypeResource,
     function changePageNumber(pageNumber) {
         vm.options.pageNumber = pageNumber;
         loadRelations();
-    } 
+    }
 
 
     /** Loads in the references one time  when content app changed */
@@ -86,12 +86,13 @@ function RelationTypeEditController($scope, $routeParams, relationTypeResource,
                 vm.relations = data;
             });
     }
-    
+
 
     function bindRelationType(relationType) {
         // Convert property value to string, since the umb-radiobutton component at the moment only handle string values.
         // Sometime later the umb-radiobutton might be able to handle value as boolean.
         relationType.isBidirectional = (relationType.isBidirectional || false).toString();
+        relationType.isDependency = (relationType.isDependency || false).toString();
 
         vm.relationType = relationType;
 
diff --git a/src/Umbraco.Web.UI.Client/src/views/relationTypes/views/relationType.html b/src/Umbraco.Web.UI.Client/src/views/relationTypes/views/relationType.html
index 8f910a6c860c..613bb5dc2b08 100644
--- a/src/Umbraco.Web.UI.Client/src/views/relationTypes/views/relationType.html
+++ b/src/Umbraco.Web.UI.Client/src/views/relationTypes/views/relationType.html
@@ -37,6 +37,26 @@
                         <div>{{model.relationType.childObjectTypeName}}</div>
                     </umb-control-group>
 
+                  <!-- IsDependency -->
+                  <umb-control-group label="@relationType_isDependency">
+                    <ul class="unstyled">
+                      <li>
+                        <umb-radiobutton name="relationTypeIsDependency"
+                                         value="true"
+                                         model="model.relationType.isDependency"
+                                         text="{{vm.labels.dependency}}">
+                        </umb-radiobutton>
+                      </li>
+                      <li>
+                        <umb-radiobutton name="relationTypeIsDependency"
+                                         value="false"
+                                         model="model.relationType.isDependency"
+                                         text="{{vm.labels.noDependency}}">
+                        </umb-radiobutton>
+                      </li>
+                    </ul>
+                  </umb-control-group>
+
                     <!-- Relation count -->
                     <umb-control-group label="@relationType_count" ng-if="model.relationType.relations.length > 0">
                         <div>{{model.relationType.relations.length}}</div>
@@ -59,5 +79,5 @@
         </div>
 
     </div>
-    
+
 </div>
diff --git a/src/Umbraco.Web.UI.Client/src/views/relationTypes/views/relationType.settings.controller.js b/src/Umbraco.Web.UI.Client/src/views/relationTypes/views/relationType.settings.controller.js
index c8e0af0aa9da..01b5367eabc7 100644
--- a/src/Umbraco.Web.UI.Client/src/views/relationTypes/views/relationType.settings.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/relationTypes/views/relationType.settings.controller.js
@@ -16,12 +16,17 @@ function RelationTypeSettingsController($scope, localizationService) {
 
         var labelKeys = [
             "relationType_parentToChild",
-            "relationType_bidirectional"
+            "relationType_bidirectional",
+            "relationType_dependency",
+            "relationType_noDependency"
+
         ];
 
         localizationService.localizeMany(labelKeys).then(function (data) {
             vm.labels.parentToChild = data[0];
             vm.labels.bidirectional = data[1];
+            vm.labels.dependency = data[2];
+            vm.labels.noDependency = data[3];
         });
     }
 
diff --git a/src/Umbraco.Web.UI.Client/src/views/users/user.controller.js b/src/Umbraco.Web.UI.Client/src/views/users/user.controller.js
index 684ce6d2f0fd..79164a245757 100644
--- a/src/Umbraco.Web.UI.Client/src/views/users/user.controller.js
+++ b/src/Umbraco.Web.UI.Client/src/views/users/user.controller.js
@@ -374,7 +374,7 @@
         }
 
         function enableUser() {
-            vm.enableUserButtonState = "busy";
+            vm.enableUserButtonState = "busfy";
             usersResource.enableUsers([vm.user.id]).then(function (data) {
                 vm.user.userState = "Active";
                 setUserDisplayState();
diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/en.xml b/src/Umbraco.Web.UI/umbraco/config/lang/en.xml
index 6364d58b5dca..d4d0d3ad4b6c 100644
--- a/src/Umbraco.Web.UI/umbraco/config/lang/en.xml
+++ b/src/Umbraco.Web.UI/umbraco/config/lang/en.xml
@@ -2390,6 +2390,9 @@ To manage your website, simply open the Umbraco backoffice and start adding cont
     <key alias="noRelations">No relations for this Relation Type</key>
     <key alias="tabRelationType">Relation Type</key>
     <key alias="tabRelations">Relations</key>
+    <key alias="isDependency">Is Dependency</key>
+    <key alias="dependency">Yes</key>
+    <key alias="noDependency">No</key>
   </area>
   <area alias="dashboardTabs">
     <key alias="contentIntro">Getting Started</key>
@@ -2467,6 +2470,15 @@ To manage your website, simply open the Umbraco backoffice and start adding cont
     <key alias="labelUsedByDocuments">Used in Documents</key>
     <key alias="labelUsedByMembers">Used in Members</key>
     <key alias="labelUsedByMedia">Used in Media</key>
+    <key alias="labelUsedItems">Items in use</key>
+    <key alias="labelUsedDescendants">Descendants in use</key>
+    <key alias="labelUsedInMediaDescendants">One or more of this item's descendants is being used in a media item.</key>
+    <key alias="labelUsedInContentDescendants">One or more of this item's descendants is being used in a content item.</key>
+    <key alias="labelUsedInMemberDescendants">One or more of this item's descendants is being used in a member.</key>
+    <key alias="deleteWarning">This item or its descendants is being used. Deletion can lead to broken links on your website.</key>
+    <key alias="unpublishWarning">This item or its descendants is being used. Unpublishing can lead to broken links on your website. Please take the appropriate actions.</key>
+    <key alias="deleteDisabledWarning">This item or its descendants is being used. Therefore, deletion has been disabled.</key>
+    <key alias="listViewDialogWarning">The following items you are trying to %0% are used by other content.</key>
   </area>
   <area alias="logViewer">
     <key alias="deleteSavedSearch">Delete Saved Search</key>
diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml b/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml
index e46e917a85cf..8e1396170e99 100644
--- a/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml
+++ b/src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml
@@ -808,6 +808,7 @@
     <key alias="new">New</key>
     <key alias="next">Next</key>
     <key alias="no">No</key>
+    <key alias="nodename">Node Name</key>
     <key alias="of">of</key>
     <key alias="off">Off</key>
     <key alias="ok">OK</key>
@@ -848,6 +849,7 @@
     <key alias="submit">Submit</key>
     <key alias="success">Success</key>
     <key alias="type">Type</key>
+    <key alias="typename">Type Name</key>
     <key alias="typeToSearch">Type to search...</key>
     <key alias="under">under</key>
     <key alias="up">Up</key>
@@ -2466,6 +2468,7 @@ To manage your website, simply open the Umbraco backoffice and start adding cont
     <key alias="parent">Parent</key>
     <key alias="child">Child</key>
     <key alias="count">Count</key>
+    <key alias="relation">Relation</key>
     <key alias="relations">Relations</key>
     <key alias="created">Created</key>
     <key alias="comment">Comment</key>
@@ -2473,6 +2476,9 @@ To manage your website, simply open the Umbraco backoffice and start adding cont
     <key alias="noRelations">No relations for this Relation Type</key>
     <key alias="tabRelationType">Relation Type</key>
     <key alias="tabRelations">Relations</key>
+    <key alias="isDependency">Is Dependency</key>
+    <key alias="dependency">Yes</key>
+    <key alias="noDependency">No</key>
   </area>
   <area alias="dashboardTabs">
     <key alias="contentIntro">Getting Started</key>
@@ -2543,13 +2549,26 @@ To manage your website, simply open the Umbraco backoffice and start adding cont
   <area alias="references">
     <key alias="tabName">References</key>
     <key alias="DataTypeNoReferences">This Data Type has no references.</key>
-    <key alias="labelUsedByDocumentTypes">Used in Document Types</key>
-    <key alias="labelUsedByMediaTypes">Used in Media Types</key>
-    <key alias="labelUsedByMemberTypes">Used in Member Types</key>
-    <key alias="usedByProperties">Used by</key>
-    <key alias="labelUsedByDocuments">Used in Documents</key>
-    <key alias="labelUsedByMembers">Used in Members</key>
-    <key alias="labelUsedByMedia">Used in Media</key>
+    <key alias="itemHasNoReferences">This item has no references.</key>
+    <key alias="labelUsedByDocumentTypes">Referenced by the following Document Types</key>
+    <key alias="labelUsedByMediaTypes">Referenced by the following Media Types</key>
+    <key alias="labelUsedByMemberTypes">Referenced by the following Member Types</key>
+    <key alias="usedByProperties">Referenced by</key>
+    <key alias="labelUsedByItems">Referenced by the following items</key>
+    <key alias="labelDependsOnThis">The following items depends on this</key>
+    <key alias="labelUsedByDocuments">Referenced by the following Documents</key>
+    <key alias="labelUsedByMembers">Referenced by the following Members</key>
+    <key alias="labelUsedByMedia">Referenced by the following Media</key>
+    <key alias="labelUsedItems">The following items are referenced</key>
+    <key alias="labelUsedDescendants">The following descending items are referenced</key>
+    <key alias="labelDependentDescendants">The following descending items has dependencies</key>
+    <key alias="labelUsedInMediaDescendants">One or more of this item's descendants is being referenced in a media item.</key>
+    <key alias="labelUsedInContentDescendants">One or more of this item's descendants is being referenced in a content item.</key>
+    <key alias="labelUsedInMemberDescendants">One or more of this item's descendants is being referenced in a member.</key>
+    <key alias="deleteWarning">This item or its descendants is being referenced. Deletion can lead to broken links on your website.</key>
+    <key alias="unpublishWarning">This item or its descendants is being referenced. Unpublishing can lead to broken links on your website. Please take the appropriate actions.</key>
+    <key alias="deleteDisabledWarning">This item or its descendants is being referenced. Therefore, deletion has been disabled.</key>
+    <key alias="listViewDialogWarning">The following items you are trying to %0% are referenced by other content.</key>
   </area>
   <area alias="logViewer">
     <key alias="deleteSavedSearch">Delete Saved Search</key>
diff --git a/tests/Umbraco.Tests.Common/Builders/RelationTypeBuilder.cs b/tests/Umbraco.Tests.Common/Builders/RelationTypeBuilder.cs
index 2bd9dc124d31..bb16cadd78f9 100644
--- a/tests/Umbraco.Tests.Common/Builders/RelationTypeBuilder.cs
+++ b/tests/Umbraco.Tests.Common/Builders/RelationTypeBuilder.cs
@@ -8,7 +8,7 @@
 namespace Umbraco.Cms.Tests.Common.Builders
 {
     public class RelationTypeBuilder
-        : ChildBuilderBase<RelationBuilder, IRelationType>,
+        : ChildBuilderBase<RelationBuilder, IRelationTypeWithIsDependency>,
             IWithIdBuilder,
             IWithAliasBuilder,
             IWithNameBuilder,
@@ -23,6 +23,7 @@ public class RelationTypeBuilder
         private DateTime? _deleteDate;
         private int? _id;
         private bool? _isBidirectional;
+        private bool? _isDependency;
         private Guid? _key;
         private string _name;
         private Guid? _parentObjectType;
@@ -42,6 +43,12 @@ public RelationTypeBuilder WithIsBidirectional(bool isBidirectional)
         {
             _isBidirectional = isBidirectional;
             return this;
+        } 
+        
+        public RelationTypeBuilder WithIsDependency(bool isDependency)
+        {
+            _isDependency = isDependency;
+            return this;
         }
 
         public RelationTypeBuilder WithChildObjectType(Guid childObjectType)
@@ -56,7 +63,7 @@ public RelationTypeBuilder WithParentObjectType(Guid parentObjectType)
             return this;
         }
 
-        public override IRelationType Build()
+        public override IRelationTypeWithIsDependency Build()
         {
             var alias = _alias ?? Guid.NewGuid().ToString();
             var name = _name ?? Guid.NewGuid().ToString();
@@ -65,11 +72,12 @@ public override IRelationType Build()
             var id = _id ?? 0;
             Guid key = _key ?? Guid.NewGuid();
             var isBidirectional = _isBidirectional ?? false;
+            var isDependency = _isDependency ?? false;
             DateTime createDate = _createDate ?? DateTime.Now;
             DateTime updateDate = _updateDate ?? DateTime.Now;
             DateTime? deleteDate = _deleteDate ?? null;
 
-            return new RelationType(name, alias, isBidirectional, parentObjectType, childObjectType)
+            return new RelationType(name, alias, isBidirectional, parentObjectType, childObjectType, isDependency)
             {
                 Id = id,
                 Key = key,
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationRepositoryTest.cs
index ee01816f09bc..bdd5257b452c 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationRepositoryTest.cs
@@ -189,23 +189,23 @@ public void Get_Paged_Parent_Entities_By_Child_Id()
 
                 // Get parent entities for child id
                 var parents = repository.GetPagedParentEntitiesByChildId(createdMedia[0].Id, 0, 11, out long totalRecords).ToList();
-                Assert.AreEqual(6, totalRecords);
-                Assert.AreEqual(6, parents.Count);
+                Assert.AreEqual(9, totalRecords);
+                Assert.AreEqual(9, parents.Count);
 
-                // add the next page
+                // Add the next page
                 parents.AddRange(repository.GetPagedParentEntitiesByChildId(createdMedia[0].Id, 1, 11, out totalRecords));
-                Assert.AreEqual(6, totalRecords);
-                Assert.AreEqual(6, parents.Count);
+                Assert.AreEqual(9, totalRecords);
+                Assert.AreEqual(9, parents.Count);
 
                 var contentEntities = parents.OfType<IDocumentEntitySlim>().ToList();
                 var mediaEntities = parents.OfType<IMediaEntitySlim>().ToList();
                 var memberEntities = parents.OfType<IMemberEntitySlim>().ToList();
 
                 Assert.AreEqual(3, contentEntities.Count);
-                Assert.AreEqual(0, mediaEntities.Count);
+                Assert.AreEqual(3, mediaEntities.Count);
                 Assert.AreEqual(3, memberEntities.Count);
 
-                // only of a certain type
+                // Only of a certain type
                 parents.AddRange(repository.GetPagedParentEntitiesByChildId(createdMedia[0].Id, 0, 100, out totalRecords, UmbracoObjectTypes.Document.GetGuid()));
                 Assert.AreEqual(3, totalRecords);
 
@@ -213,7 +213,32 @@ public void Get_Paged_Parent_Entities_By_Child_Id()
                 Assert.AreEqual(3, totalRecords);
 
                 parents.AddRange(repository.GetPagedParentEntitiesByChildId(createdMedia[0].Id, 0, 100, out totalRecords, UmbracoObjectTypes.Media.GetGuid()));
-                Assert.AreEqual(0, totalRecords);
+                Assert.AreEqual(3, totalRecords);
+
+                // Test relations on content
+                var contentParents = repository.GetPagedParentEntitiesByChildId(createdContent[0].Id, 0, int.MaxValue, out totalRecords).ToList();
+                Assert.AreEqual(6, totalRecords);
+                Assert.AreEqual(6, contentParents.Count);
+
+                // Test getting relations of specified relation types
+                var relatedMediaRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
+                var relatedContentRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedDocumentAlias);
+
+                parents = repository.GetPagedParentEntitiesByChildId(createdMedia[0].Id, 0, 11, out totalRecords, new int[] { relatedContentRelType.Id, relatedMediaRelType.Id }).ToList();
+                Assert.AreEqual(6, totalRecords);
+                Assert.AreEqual(6, parents.Count);
+
+                parents = repository.GetPagedParentEntitiesByChildId(createdMedia[0].Id, 1, 11, out totalRecords, new int[] { relatedContentRelType.Id, relatedMediaRelType.Id }).ToList();
+                Assert.AreEqual(6, totalRecords);
+                Assert.AreEqual(0, parents.Count);
+
+                parents = repository.GetPagedParentEntitiesByChildId(createdContent[0].Id, 0, 6, out totalRecords, new int[] { relatedContentRelType.Id, relatedMediaRelType.Id }).ToList();
+                Assert.AreEqual(3, totalRecords);
+                Assert.AreEqual(3, parents.Count);
+
+                parents = repository.GetPagedParentEntitiesByChildId(createdContent[0].Id, 1, 6, out totalRecords, new int[] { relatedContentRelType.Id, relatedMediaRelType.Id }).ToList();
+                Assert.AreEqual(3, totalRecords);
+                Assert.AreEqual(0, parents.Count);
             }
         }
 
@@ -255,19 +280,19 @@ public void Get_Paged_Child_Entities_By_Parent_Id()
 
                 // Get parent entities for child id
                 var parents = repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 0, 6, out long totalRecords).ToList();
-                Assert.AreEqual(3, totalRecords);
-                Assert.AreEqual(3, parents.Count);
+                Assert.AreEqual(6, totalRecords);
+                Assert.AreEqual(6, parents.Count);
 
-                // add the next page
+                // Add the next page
                 parents.AddRange(repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 1, 6, out totalRecords));
-                Assert.AreEqual(3, totalRecords);
-                Assert.AreEqual(3, parents.Count);
+                Assert.AreEqual(6, totalRecords);
+                Assert.AreEqual(6, parents.Count);
 
                 var contentEntities = parents.OfType<IDocumentEntitySlim>().ToList();
                 var mediaEntities = parents.OfType<IMediaEntitySlim>().ToList();
                 var memberEntities = parents.OfType<IMemberEntitySlim>().ToList();
 
-                Assert.AreEqual(0, contentEntities.Count);
+                Assert.AreEqual(3, contentEntities.Count);
                 Assert.AreEqual(3, mediaEntities.Count);
                 Assert.AreEqual(0, memberEntities.Count);
 
@@ -280,6 +305,18 @@ public void Get_Paged_Child_Entities_By_Parent_Id()
 
                 parents.AddRange(repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 0, 100, out totalRecords, UmbracoObjectTypes.Member.GetGuid()));
                 Assert.AreEqual(0, totalRecords);
+
+                // Test getting relations of specified relation types
+                IRelationType relatedMediaRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
+                IRelationType relatedContentRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedDocumentAlias);
+
+                parents = repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 0, 6, out totalRecords, new int[] { relatedContentRelType.Id, relatedMediaRelType.Id }).ToList();
+                Assert.AreEqual(3, totalRecords);
+                Assert.AreEqual(3, parents.Count);
+
+                parents = repository.GetPagedChildEntitiesByParentId(createdContent[0].Id, 1, 6, out totalRecords, new int[] { relatedContentRelType.Id, relatedMediaRelType.Id }).ToList();
+                Assert.AreEqual(3, totalRecords);
+                Assert.AreEqual(0, parents.Count);
             }
         }
 
@@ -296,6 +333,15 @@ private void CreateTestDataForPagingTests(out List<IContent> createdContent, out
                 createdContent.Add(c1);
             }
 
+            // Create related content
+            var relatedContent = new List<IContent>();
+            for (int i = 0; i < 3; i++)
+            {
+                Content c1 = ContentBuilder.CreateBasicContent(contentType);
+                ContentService.Save(c1);
+                relatedContent.Add(c1);
+            }
+
             // Create media
             createdMedia = new List<IMedia>();
             MediaType imageType = MediaTypeBuilder.CreateImageMediaType("myImage");
@@ -313,14 +359,24 @@ private void CreateTestDataForPagingTests(out List<IContent> createdContent, out
             createdMembers = MemberBuilder.CreateSimpleMembers(memberType, 3).ToList();
             GetMemberService().Save(createdMembers);
 
-            IRelationType relType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
+            IRelationType relatedMediaRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
+            IRelationType relatedContentRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedDocumentAlias);
 
             // Relate content to media
             foreach (IContent content in createdContent)
             {
                 foreach (IMedia media in createdMedia)
                 {
-                    RelationService.Relate(content.Id, media.Id, relType);
+                    RelationService.Relate(content.Id, media.Id, relatedMediaRelType);
+                }
+            }
+
+            // Relate content to content
+            foreach (IContent relContent in relatedContent)
+            {
+                foreach (IContent content in createdContent)
+                {
+                    RelationService.Relate(relContent.Id, content.Id, relatedContentRelType);
                 }
             }
 
@@ -329,7 +385,67 @@ private void CreateTestDataForPagingTests(out List<IContent> createdContent, out
             {
                 foreach (IMedia media in createdMedia)
                 {
-                    RelationService.Relate(member.Id, media.Id, relType);
+                    RelationService.Relate(member.Id, media.Id, relatedMediaRelType);
+                }
+            }
+
+            // Create copied content
+            var copiedContent = new List<IContent>();
+            for (int i = 0; i < 3; i++)
+            {
+                Content c1 = ContentBuilder.CreateBasicContent(contentType);
+                ContentService.Save(c1);
+                copiedContent.Add(c1);
+            }
+
+            IRelationType copiedContentRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias);
+
+            // Relate content to content (mimics copy)
+            foreach (IContent content in createdContent)
+            {
+                foreach (IContent cpContent in copiedContent)
+                {
+                    RelationService.Relate(content.Id, cpContent.Id, copiedContentRelType);
+                }
+            }
+
+            // Create trashed content
+            var trashedContent = new List<IContent>();
+            for (int i = 0; i < 3; i++)
+            {
+                Content c1 = ContentBuilder.CreateBasicContent(contentType);
+                ContentService.Save(c1);
+                trashedContent.Add(c1);
+            }
+
+            IRelationType trashedRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteAlias);
+
+            // Relate to trashed content
+            foreach (IContent trContent in trashedContent)
+            {
+                foreach (IContent content in createdContent)
+                {
+                    RelationService.Relate(trContent.Id, content.Id, trashedRelType);
+                }
+            }
+
+            // Create trashed media
+            var trashedMedia = new List<IMedia>();
+            for (int i = 0; i < 3; i++)
+            {
+                Media m1 = MediaBuilder.CreateMediaImage(imageType, -1);
+                MediaService.Save(m1);
+                trashedMedia.Add(m1);
+            }
+
+            IRelationType trashedMediaRelType = RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias);
+
+            // Relate to trashed media
+            foreach (IMedia trMedia in trashedMedia)
+            {
+                foreach (IMedia media in createdMedia)
+                {
+                    RelationService.Relate(trMedia.Id, media.Id, trashedMediaRelType);
                 }
             }
         }
@@ -417,14 +533,16 @@ public void CreateTestData()
                 "relateContentOnCopy",
                 true,
                 Constants.ObjectTypes.Document,
-                new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972"));
+                new Guid("C66BA18E-EAF3-4CFF-8A22-41B16D66A972"),
+                false);
 
             _relateContentType = new RelationType(
                 "Relate ContentType on Copy",
                 "relateContentTypeOnCopy",
                 true,
                 Constants.ObjectTypes.DocumentType,
-                new Guid("A2CB7800-F571-4787-9638-BC48539A0EFB"));
+                new Guid("A2CB7800-F571-4787-9638-BC48539A0EFB"),
+                false);
 
             using (IScope scope = ScopeProvider.CreateScope())
             {
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationTypeRepositoryTest.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationTypeRepositoryTest.cs
index 4b0a23464f38..16c88e7cf9d3 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationTypeRepositoryTest.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Persistence/Repositories/RelationTypeRepositoryTest.cs
@@ -36,7 +36,7 @@ public void Can_Perform_Add_On_RelationTypeRepository()
                 RelationTypeRepository repository = CreateRepository(provider);
 
                 // Act
-                var relateMemberToContent = new RelationType("Relate Member to Content", "relateMemberToContent", true, Constants.ObjectTypes.Member, Constants.ObjectTypes.Document);
+                var relateMemberToContent = new RelationType("Relate Member to Content", "relateMemberToContent", true, Constants.ObjectTypes.Member, Constants.ObjectTypes.Document, true);
 
                 repository.Save(relateMemberToContent);
 
@@ -101,12 +101,13 @@ public void Can_Perform_Get_On_RelationTypeRepository()
                 RelationTypeRepository repository = CreateRepository(provider);
 
                 // Act
-                IRelationType relationType = repository.Get(8);
+                var relationType = repository.Get(8) as IRelationTypeWithIsDependency;
 
                 // Assert
                 Assert.That(relationType, Is.Not.Null);
                 Assert.That(relationType.HasIdentity, Is.True);
                 Assert.That(relationType.IsBidirectional, Is.True);
+                Assert.That(relationType.IsDependency, Is.True);
                 Assert.That(relationType.Alias, Is.EqualTo("relateContentToMedia"));
                 Assert.That(relationType.Name, Is.EqualTo("Relate Content to Media"));
                 Assert.That(relationType.ChildObjectType, Is.EqualTo(Constants.ObjectTypes.Media));
@@ -215,9 +216,9 @@ public void Can_Perform_GetByQuery_On_RelationTypeRepository()
 
         public void CreateTestData()
         {
-            var relateContent = new RelationType("Relate Content on Copy", "relateContentOnCopy", true, Constants.ObjectTypes.Document, Constants.ObjectTypes.Document);
-            var relateContentType = new RelationType("Relate ContentType on Copy", "relateContentTypeOnCopy", true, Constants.ObjectTypes.DocumentType, Constants.ObjectTypes.DocumentType);
-            var relateContentMedia = new RelationType("Relate Content to Media", "relateContentToMedia", true, Constants.ObjectTypes.Document, Constants.ObjectTypes.Media);
+            var relateContent = new RelationType("Relate Content on Copy", "relateContentOnCopy", true, Constants.ObjectTypes.Document, Constants.ObjectTypes.Document, false);
+            var relateContentType = new RelationType("Relate ContentType on Copy", "relateContentTypeOnCopy", true, Constants.ObjectTypes.DocumentType, Constants.ObjectTypes.DocumentType, false);
+            var relateContentMedia = new RelationType("Relate Content to Media", "relateContentToMedia", true, Constants.ObjectTypes.Document, Constants.ObjectTypes.Media, true);
 
             IScopeProvider provider = ScopeProvider;
             using (IScope scope = provider.CreateScope())
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceTests.cs
index 5b033fcd4269..4f0c489516bc 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/ContentServiceTests.cs
@@ -1970,7 +1970,7 @@ public void Can_Empty_RecycleBin_With_Content_That_Has_All_Related_Data()
             UserService.Save(admin);
 
             RelationService.Save(new RelationType("test", "test", false, Constants.ObjectTypes.Document,
-                Constants.ObjectTypes.Document));
+                Constants.ObjectTypes.Document, false));
             Assert.IsNotNull(RelationService.Relate(content1, content2, "test"));
 
             PublicAccessService.Save(new PublicAccessEntry(content1, content2, content2,
diff --git a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/RelationServiceTests.cs b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/RelationServiceTests.cs
index 3edba867601b..0156100f0ae5 100644
--- a/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/RelationServiceTests.cs
+++ b/tests/Umbraco.Tests.Integration/Umbraco.Infrastructure/Services/RelationServiceTests.cs
@@ -266,4 +266,4 @@ private IEnumerable<IRelation> CreateRelations(int count)
 
         // TODO: Create a relation for entities of the wrong Entity Type (GUID) based on the Relation Type's defined parent/child object types
     }
-}
+}
\ No newline at end of file
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Tests.Common/Builders/RelationBuilderTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Tests.Common/Builders/RelationBuilderTests.cs
index 67f887d123dc..bde8b8f09281 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Tests.Common/Builders/RelationBuilderTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Tests.Common/Builders/RelationBuilderTests.cs
@@ -44,6 +44,7 @@ public void Is_Built_Correctly()
                     .WithAlias(relationTypeAlias)
                     .WithName(relationTypeName)
                     .WithIsBidirectional(false)
+                    .WithIsDependency(true)
                     .WithParentObjectType(parentObjectType)
                     .WithChildObjectType(childObjectType)
                     .Done()
@@ -61,6 +62,8 @@ public void Is_Built_Correctly()
             Assert.AreEqual(relationTypeAlias, relation.RelationType.Alias);
             Assert.AreEqual(relationTypeName, relation.RelationType.Name);
             Assert.IsFalse(relation.RelationType.IsBidirectional);
+            
+            Assert.IsTrue((relation.RelationType as IRelationTypeWithIsDependency).IsDependency);
             Assert.AreEqual(parentObjectType, relation.RelationType.ParentObjectType);
             Assert.AreEqual(childObjectType, relation.RelationType.ChildObjectType);
         }
diff --git a/tests/Umbraco.Tests.UnitTests/Umbraco.Tests.Common/Builders/RelationTypeBuilderTests.cs b/tests/Umbraco.Tests.UnitTests/Umbraco.Tests.Common/Builders/RelationTypeBuilderTests.cs
index 877023f82f70..e99f5ae273a1 100644
--- a/tests/Umbraco.Tests.UnitTests/Umbraco.Tests.Common/Builders/RelationTypeBuilderTests.cs
+++ b/tests/Umbraco.Tests.UnitTests/Umbraco.Tests.Common/Builders/RelationTypeBuilderTests.cs
@@ -26,11 +26,12 @@ public void Is_Built_Correctly()
             var parentObjectType = Guid.NewGuid();
             var childObjectType = Guid.NewGuid();
             const bool isBidirectional = true;
+            const bool isDependency = true;
 
             var builder = new RelationTypeBuilder();
 
             // Act
-            IRelationType relationType = builder
+            var relationType = builder
                 .WithId(id)
                 .WithAlias(alias)
                 .WithName(name)
@@ -41,6 +42,7 @@ public void Is_Built_Correctly()
                 .WithParentObjectType(parentObjectType)
                 .WithChildObjectType(childObjectType)
                 .WithIsBidirectional(isBidirectional)
+                .WithIsDependency(isDependency)
                 .Build();
 
             // Assert
@@ -54,6 +56,7 @@ public void Is_Built_Correctly()
             Assert.AreEqual(parentObjectType, relationType.ParentObjectType);
             Assert.AreEqual(childObjectType, relationType.ChildObjectType);
             Assert.AreEqual(isBidirectional, relationType.IsBidirectional);
+            Assert.AreEqual(isDependency, relationType.IsDependency);
         }
     }
 }