Rename the default entities

samples/Mvc.Server/Controllers/AuthorizationController.cs

@@ -29,16 +29,16 @@ namespace Mvc.Server
 {
     public class AuthorizationController : Controller
     {
-        private readonly OpenIddictApplicationManager<OpenIddictApplication> _applicationManager;
-        private readonly OpenIddictAuthorizationManager<OpenIddictAuthorization> _authorizationManager;
-        private readonly OpenIddictScopeManager<OpenIddictScope> _scopeManager;
+        private readonly OpenIddictApplicationManager<OpenIddictEntityFrameworkCoreApplication> _applicationManager;
+        private readonly OpenIddictAuthorizationManager<OpenIddictEntityFrameworkCoreAuthorization> _authorizationManager;
+        private readonly OpenIddictScopeManager<OpenIddictEntityFrameworkCoreScope> _scopeManager;
         private readonly SignInManager<ApplicationUser> _signInManager;
         private readonly UserManager<ApplicationUser> _userManager;
 
         public AuthorizationController(
-            OpenIddictApplicationManager<OpenIddictApplication> applicationManager,
-            OpenIddictAuthorizationManager<OpenIddictAuthorization> authorizationManager,
-            OpenIddictScopeManager<OpenIddictScope> scopeManager,
+            OpenIddictApplicationManager<OpenIddictEntityFrameworkCoreApplication> applicationManager,
+            OpenIddictAuthorizationManager<OpenIddictEntityFrameworkCoreAuthorization> authorizationManager,
+            OpenIddictScopeManager<OpenIddictEntityFrameworkCoreScope> scopeManager,
             SignInManager<ApplicationUser> signInManager,
             UserManager<ApplicationUser> userManager)
         {

samples/Mvc.Server/Worker.cs

@@ -30,7 +30,7 @@ namespace Mvc.Server
 
             static async Task RegisterApplicationsAsync(IServiceProvider provider)
             {
-                var manager = provider.GetRequiredService<OpenIddictApplicationManager<OpenIddictApplication>>();
+                var manager = provider.GetRequiredService<OpenIddictApplicationManager<OpenIddictEntityFrameworkCoreApplication>>();
 
                 if (await manager.FindByClientIdAsync("mvc") == null)
                 {
@@ -106,7 +106,7 @@ namespace Mvc.Server
 
             static async Task RegisterScopesAsync(IServiceProvider provider)
             {
-                var manager = provider.GetRequiredService<OpenIddictScopeManager<OpenIddictScope>>();
+                var manager = provider.GetRequiredService<OpenIddictScopeManager<OpenIddictEntityFrameworkCoreScope>>();
 
                 if (await manager.FindByNameAsync("demo_api") == null)
                 {

src/OpenIddict.EntityFramework.Models/OpenIddictApplication.cs → src/OpenIddict.EntityFramework.Models/OpenIddictEntityFrameworkApplication.cs

@@ -13,9 +13,9 @@ namespace OpenIddict.EntityFramework.Models
     /// <summary>
     /// Represents an OpenIddict application.
     /// </summary>
-    public class OpenIddictApplication : OpenIddictApplication<string, OpenIddictAuthorization, OpenIddictToken>
+    public class OpenIddictEntityFrameworkApplication : OpenIddictEntityFrameworkApplication<string, OpenIddictEntityFrameworkAuthorization, OpenIddictEntityFrameworkToken>
     {
-        public OpenIddictApplication()
+        public OpenIddictEntityFrameworkApplication()
         {
             // Generate a new string identifier.
             Id = Guid.NewGuid().ToString();
@@ -26,7 +26,7 @@ namespace OpenIddict.EntityFramework.Models
     /// Represents an OpenIddict application.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; ClientId = {ClientId,nq} ; Type = {Type,nq}")]
-    public class OpenIddictApplication<TKey, TAuthorization, TToken> where TKey : IEquatable<TKey>
+    public class OpenIddictEntityFrameworkApplication<TKey, TAuthorization, TToken> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Gets the list of the authorizations associated with this application.

src/OpenIddict.EntityFramework.Models/OpenIddictAuthorization.cs → src/OpenIddict.EntityFramework.Models/OpenIddictEntityFrameworkAuthorization.cs

@@ -13,9 +13,9 @@ namespace OpenIddict.EntityFramework.Models
     /// <summary>
     /// Represents an OpenIddict authorization.
     /// </summary>
-    public class OpenIddictAuthorization : OpenIddictAuthorization<string, OpenIddictApplication, OpenIddictToken>
+    public class OpenIddictEntityFrameworkAuthorization : OpenIddictEntityFrameworkAuthorization<string, OpenIddictEntityFrameworkApplication, OpenIddictEntityFrameworkToken>
     {
-        public OpenIddictAuthorization()
+        public OpenIddictEntityFrameworkAuthorization()
         {
             // Generate a new string identifier.
             Id = Guid.NewGuid().ToString();
@@ -26,7 +26,7 @@ namespace OpenIddict.EntityFramework.Models
     /// Represents an OpenIddict authorization.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; Subject = {Subject,nq} ; Type = {Type,nq} ; Status = {Status,nq}")]
-    public class OpenIddictAuthorization<TKey, TApplication, TToken> where TKey : IEquatable<TKey>
+    public class OpenIddictEntityFrameworkAuthorization<TKey, TApplication, TToken> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Gets or sets the application associated with the current authorization.

src/OpenIddict.EntityFramework.Models/OpenIddictScope.cs → src/OpenIddict.EntityFramework.Models/OpenIddictEntityFrameworkScope.cs

@@ -12,9 +12,9 @@ namespace OpenIddict.EntityFramework.Models
     /// <summary>
     /// Represents an OpenIddict scope.
     /// </summary>
-    public class OpenIddictScope : OpenIddictScope<string>
+    public class OpenIddictEntityFrameworkScope : OpenIddictEntityFrameworkScope<string>
     {
-        public OpenIddictScope()
+        public OpenIddictEntityFrameworkScope()
         {
             // Generate a new string identifier.
             Id = Guid.NewGuid().ToString();
@@ -25,7 +25,7 @@ namespace OpenIddict.EntityFramework.Models
     /// Represents an OpenIddict scope.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; Name = {Name,nq}")]
-    public class OpenIddictScope<TKey> where TKey : IEquatable<TKey>
+    public class OpenIddictEntityFrameworkScope<TKey> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Gets or sets the concurrency token.

src/OpenIddict.EntityFramework.Models/OpenIddictToken.cs → src/OpenIddict.EntityFramework.Models/OpenIddictEntityFrameworkToken.cs

@@ -12,9 +12,9 @@ namespace OpenIddict.EntityFramework.Models
     /// <summary>
     /// Represents an OpenIddict token.
     /// </summary>
-    public class OpenIddictToken : OpenIddictToken<string, OpenIddictApplication, OpenIddictAuthorization>
+    public class OpenIddictEntityFrameworkToken : OpenIddictEntityFrameworkToken<string, OpenIddictEntityFrameworkApplication, OpenIddictEntityFrameworkAuthorization>
     {
-        public OpenIddictToken()
+        public OpenIddictEntityFrameworkToken()
         {
             // Generate a new string identifier.
             Id = Guid.NewGuid().ToString();
@@ -25,7 +25,7 @@ namespace OpenIddict.EntityFramework.Models
     /// Represents an OpenIddict token.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; Subject = {Subject,nq} ; Type = {Type,nq} ; Status = {Status,nq}")]
-    public class OpenIddictToken<TKey, TApplication, TAuthorization> where TKey : IEquatable<TKey>
+    public class OpenIddictEntityFrameworkToken<TKey, TApplication, TAuthorization> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Gets or sets the application associated with the current token.

src/OpenIddict.EntityFramework/Configurations/OpenIddictApplicationConfiguration.cs → src/OpenIddict.EntityFramework/Configurations/OpenIddictEntityFrameworkApplicationConfiguration.cs

@@ -21,13 +21,13 @@ namespace OpenIddict.EntityFramework
     /// <typeparam name="TToken">The type of the Token entity.</typeparam>
     /// <typeparam name="TKey">The type of the Key entity.</typeparam>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public class OpenIddictApplicationConfiguration<TApplication, TAuthorization, TToken, TKey> : EntityTypeConfiguration<TApplication>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+    public class OpenIddictEntityFrameworkApplicationConfiguration<TApplication, TAuthorization, TToken, TKey> : EntityTypeConfiguration<TApplication>
+        where TApplication : OpenIddictEntityFrameworkApplication<TKey, TAuthorization, TToken>
+        where TAuthorization : OpenIddictEntityFrameworkAuthorization<TKey, TApplication, TToken>
+        where TToken : OpenIddictEntityFrameworkToken<TKey, TApplication, TAuthorization>
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictApplicationConfiguration()
+        public OpenIddictEntityFrameworkApplicationConfiguration()
         {
             // Warning: optional foreign keys MUST NOT be added as CLR properties because
             // Entity Framework would throw an exception due to the TKey generic parameter
@@ -55,14 +55,16 @@ namespace OpenIddict.EntityFramework
                 .WithOptional(authorization => authorization.Application)
                 .Map(association =>
                 {
-                    association.MapKey(nameof(OpenIddictAuthorization.Application) + nameof(OpenIddictApplication.Id));
+                    association.MapKey(nameof(OpenIddictEntityFrameworkAuthorization.Application) +
+                                       nameof(OpenIddictEntityFrameworkApplication.Id));
                 });
 
             HasMany(application => application.Tokens)
                 .WithOptional(token => token.Application)
                 .Map(association =>
                 {
-                    association.MapKey(nameof(OpenIddictToken.Application) + nameof(OpenIddictApplication.Id));
+                    association.MapKey(nameof(OpenIddictEntityFrameworkToken.Application) +
+                                       nameof(OpenIddictEntityFrameworkApplication.Id));
                 });
 
             ToTable("OpenIddictApplications");

src/OpenIddict.EntityFramework/Configurations/OpenIddictAuthorizationConfiguration.cs → src/OpenIddict.EntityFramework/Configurations/OpenIddictEntityFrameworkAuthorizationConfiguration.cs

@@ -19,13 +19,13 @@ namespace OpenIddict.EntityFramework
     /// <typeparam name="TToken">The type of the Token entity.</typeparam>
     /// <typeparam name="TKey">The type of the Key entity.</typeparam>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public class OpenIddictAuthorizationConfiguration<TAuthorization, TApplication, TToken, TKey> : EntityTypeConfiguration<TAuthorization>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+    public class OpenIddictEntityFrameworkAuthorizationConfiguration<TAuthorization, TApplication, TToken, TKey> : EntityTypeConfiguration<TAuthorization>
+        where TAuthorization : OpenIddictEntityFrameworkAuthorization<TKey, TApplication, TToken>
+        where TApplication : OpenIddictEntityFrameworkApplication<TKey, TAuthorization, TToken>
+        where TToken : OpenIddictEntityFrameworkToken<TKey, TApplication, TAuthorization>
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictAuthorizationConfiguration()
+        public OpenIddictEntityFrameworkAuthorizationConfiguration()
         {
             // Warning: optional foreign keys MUST NOT be added as CLR properties because
             // Entity Framework would throw an exception due to the TKey generic parameter
@@ -50,7 +50,8 @@ namespace OpenIddict.EntityFramework
 
             HasMany(authorization => authorization.Tokens)
                 .WithOptional(token => token.Authorization)
-                .Map(association => association.MapKey(nameof(OpenIddictToken.Authorization) + nameof(OpenIddictAuthorization.Id)))
+                .Map(association => association.MapKey(nameof(OpenIddictEntityFrameworkToken.Authorization) +
+                                                       nameof(OpenIddictEntityFrameworkAuthorization.Id)))
                 .WillCascadeOnDelete();
 
             ToTable("OpenIddictAuthorizations");

src/OpenIddict.EntityFramework/Configurations/OpenIddictScopeConfiguration.cs → src/OpenIddict.EntityFramework/Configurations/OpenIddictEntityFrameworkScopeConfiguration.cs

@@ -19,11 +19,11 @@ namespace OpenIddict.EntityFramework
     /// <typeparam name="TScope">The type of the Scope entity.</typeparam>
     /// <typeparam name="TKey">The type of the Key entity.</typeparam>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public class OpenIddictScopeConfiguration<TScope, TKey> : EntityTypeConfiguration<TScope>
-        where TScope : OpenIddictScope<TKey>
+    public class OpenIddictEntityFrameworkScopeConfiguration<TScope, TKey> : EntityTypeConfiguration<TScope>
+        where TScope : OpenIddictEntityFrameworkScope<TKey>
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictScopeConfiguration()
+        public OpenIddictEntityFrameworkScopeConfiguration()
         {
             // Warning: optional foreign keys MUST NOT be added as CLR properties because
             // Entity Framework would throw an exception due to the TKey generic parameter

src/OpenIddict.EntityFramework/Configurations/OpenIddictTokenConfiguration.cs → src/OpenIddict.EntityFramework/Configurations/OpenIddictEntityFrameworkTokenConfiguration.cs

@@ -21,13 +21,13 @@ namespace OpenIddict.EntityFramework
     /// <typeparam name="TAuthorization">The type of the Authorization entity.</typeparam>
     /// <typeparam name="TKey">The type of the Key entity.</typeparam>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public class OpenIddictTokenConfiguration<TToken, TApplication, TAuthorization, TKey> : EntityTypeConfiguration<TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
+    public class OpenIddictEntityFrameworkTokenConfiguration<TToken, TApplication, TAuthorization, TKey> : EntityTypeConfiguration<TToken>
+        where TToken : OpenIddictEntityFrameworkToken<TKey, TApplication, TAuthorization>
+        where TApplication : OpenIddictEntityFrameworkApplication<TKey, TAuthorization, TToken>
+        where TAuthorization : OpenIddictEntityFrameworkAuthorization<TKey, TApplication, TToken>
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictTokenConfiguration()
+        public OpenIddictEntityFrameworkTokenConfiguration()
         {
             // Warning: optional foreign keys MUST NOT be added as CLR properties because
             // Entity Framework would throw an exception due to the TKey generic parameter

src/OpenIddict.EntityFramework/OpenIddictEntityFrameworkBuilder.cs

@@ -58,10 +58,10 @@ namespace Microsoft.Extensions.DependencyInjection
         /// </summary>
         /// <returns>The <see cref="OpenIddictEntityFrameworkBuilder"/>.</returns>
         public OpenIddictEntityFrameworkBuilder ReplaceDefaultEntities<TApplication, TAuthorization, TScope, TToken, TKey>()
-            where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-            where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-            where TScope : OpenIddictScope<TKey>
-            where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+            where TApplication : OpenIddictEntityFrameworkApplication<TKey, TAuthorization, TToken>
+            where TAuthorization : OpenIddictEntityFrameworkAuthorization<TKey, TApplication, TToken>
+            where TScope : OpenIddictEntityFrameworkScope<TKey>
+            where TToken : OpenIddictEntityFrameworkToken<TKey, TApplication, TAuthorization>
             where TKey : IEquatable<TKey>
         {
             // Note: unlike Entity Framework Core 1.x/2.x/3.x, Entity Framework 6.x

src/OpenIddict.EntityFramework/OpenIddictEntityFrameworkExtensions.cs

@@ -36,25 +36,25 @@ namespace Microsoft.Extensions.DependencyInjection
             // in case case-sensitive stores were registered before this extension was called.
             builder.Configure(options => options.DisableAdditionalFiltering = false);
 
-            builder.SetDefaultApplicationEntity<OpenIddictApplication>()
-                   .SetDefaultAuthorizationEntity<OpenIddictAuthorization>()
-                   .SetDefaultScopeEntity<OpenIddictScope>()
-                   .SetDefaultTokenEntity<OpenIddictToken>();
+            builder.SetDefaultApplicationEntity<OpenIddictEntityFrameworkApplication>()
+                   .SetDefaultAuthorizationEntity<OpenIddictEntityFrameworkAuthorization>()
+                   .SetDefaultScopeEntity<OpenIddictEntityFrameworkScope>()
+                   .SetDefaultTokenEntity<OpenIddictEntityFrameworkToken>();
 
-            builder.ReplaceApplicationStoreResolver<OpenIddictApplicationStoreResolver>()
-                   .ReplaceAuthorizationStoreResolver<OpenIddictAuthorizationStoreResolver>()
-                   .ReplaceScopeStoreResolver<OpenIddictScopeStoreResolver>()
-                   .ReplaceTokenStoreResolver<OpenIddictTokenStoreResolver>();
+            builder.ReplaceApplicationStoreResolver<OpenIddictEntityFrameworkApplicationStoreResolver>()
+                   .ReplaceAuthorizationStoreResolver<OpenIddictEntityFrameworkAuthorizationStoreResolver>()
+                   .ReplaceScopeStoreResolver<OpenIddictEntityFrameworkScopeStoreResolver>()
+                   .ReplaceTokenStoreResolver<OpenIddictEntityFrameworkTokenStoreResolver>();
 
-            builder.Services.TryAddSingleton<OpenIddictApplicationStoreResolver.TypeResolutionCache>();
-            builder.Services.TryAddSingleton<OpenIddictAuthorizationStoreResolver.TypeResolutionCache>();
-            builder.Services.TryAddSingleton<OpenIddictScopeStoreResolver.TypeResolutionCache>();
-            builder.Services.TryAddSingleton<OpenIddictTokenStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictEntityFrameworkApplicationStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictEntityFrameworkAuthorizationStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictEntityFrameworkScopeStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictEntityFrameworkTokenStoreResolver.TypeResolutionCache>();
 
-            builder.Services.TryAddScoped(typeof(OpenIddictApplicationStore<,,,,>));
-            builder.Services.TryAddScoped(typeof(OpenIddictAuthorizationStore<,,,,>));
-            builder.Services.TryAddScoped(typeof(OpenIddictScopeStore<,,>));
-            builder.Services.TryAddScoped(typeof(OpenIddictTokenStore<,,,,>));
+            builder.Services.TryAddScoped(typeof(OpenIddictEntityFrameworkApplicationStore<,,,,>));
+            builder.Services.TryAddScoped(typeof(OpenIddictEntityFrameworkAuthorizationStore<,,,,>));
+            builder.Services.TryAddScoped(typeof(OpenIddictEntityFrameworkScopeStore<,,>));
+            builder.Services.TryAddScoped(typeof(OpenIddictEntityFrameworkTokenStore<,,,,>));
 
             return new OpenIddictEntityFrameworkBuilder(builder.Services);
         }

src/OpenIddict.EntityFramework/OpenIddictEntityFrameworkHelpers.cs

@@ -26,10 +26,10 @@ namespace System.Data.Entity
         /// <param name="builder">The builder used to configure the Entity Framework context.</param>
         /// <returns>The Entity Framework context builder.</returns>
         public static DbModelBuilder UseOpenIddict([NotNull] this DbModelBuilder builder)
-            => builder.UseOpenIddict<OpenIddictApplication,
-                                     OpenIddictAuthorization,
-                                     OpenIddictScope,
-                                     OpenIddictToken, string>();
+            => builder.UseOpenIddict<OpenIddictEntityFrameworkApplication,
+                                     OpenIddictEntityFrameworkAuthorization,
+                                     OpenIddictEntityFrameworkScope,
+                                     OpenIddictEntityFrameworkToken, string>();
 
         /// <summary>
         /// Registers the OpenIddict entity sets in the Entity Framework 6.x
@@ -40,10 +40,10 @@ namespace System.Data.Entity
         /// <param name="builder">The builder used to configure the Entity Framework context.</param>
         /// <returns>The Entity Framework context builder.</returns>
         public static DbModelBuilder UseOpenIddict<TApplication, TAuthorization, TScope, TToken, TKey>([NotNull] this DbModelBuilder builder)
-            where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-            where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-            where TScope : OpenIddictScope<TKey>
-            where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+            where TApplication : OpenIddictEntityFrameworkApplication<TKey, TAuthorization, TToken>
+            where TAuthorization : OpenIddictEntityFrameworkAuthorization<TKey, TApplication, TToken>
+            where TScope : OpenIddictEntityFrameworkScope<TKey>
+            where TToken : OpenIddictEntityFrameworkToken<TKey, TApplication, TAuthorization>
             where TKey : IEquatable<TKey>
         {
             if (builder == null)
@@ -52,10 +52,10 @@ namespace System.Data.Entity
             }
 
             builder.Configurations
-                .Add(new OpenIddictApplicationConfiguration<TApplication, TAuthorization, TToken, TKey>())
-                .Add(new OpenIddictAuthorizationConfiguration<TAuthorization, TApplication, TToken, TKey>())
-                .Add(new OpenIddictScopeConfiguration<TScope, TKey>())
-                .Add(new OpenIddictTokenConfiguration<TToken, TApplication, TAuthorization, TKey>());
+                .Add(new OpenIddictEntityFrameworkApplicationConfiguration<TApplication, TAuthorization, TToken, TKey>())
+                .Add(new OpenIddictEntityFrameworkAuthorizationConfiguration<TAuthorization, TApplication, TToken, TKey>())
+                .Add(new OpenIddictEntityFrameworkScopeConfiguration<TScope, TKey>())
+                .Add(new OpenIddictEntityFrameworkTokenConfiguration<TToken, TApplication, TAuthorization, TKey>());
 
             return builder;
         }

src/OpenIddict.EntityFramework/Resolvers/OpenIddictApplicationStoreResolver.cs → src/OpenIddict.EntityFramework/Resolvers/OpenIddictEntityFrameworkApplicationStoreResolver.cs

@@ -19,13 +19,13 @@ namespace OpenIddict.EntityFramework
     /// <summary>
     /// Exposes a method allowing to resolve an application store.
     /// </summary>
-    public class OpenIddictApplicationStoreResolver : IOpenIddictApplicationStoreResolver
+    public class OpenIddictEntityFrameworkApplicationStoreResolver : IOpenIddictApplicationStoreResolver
     {
         private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkOptions> _options;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictApplicationStoreResolver(
+        public OpenIddictEntityFrameworkApplicationStoreResolver(
             [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options,
             [NotNull] IServiceProvider provider)
@@ -51,14 +51,14 @@ namespace OpenIddict.EntityFramework
 
             var type = _cache.GetOrAdd(typeof(TApplication), key =>
             {
-                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictApplication<,,>));
+                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictEntityFrameworkApplication<,,>));
                 if (root == null)
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified application type is not compatible with the Entity Framework 6.x stores.")
                         .Append("When enabling the Entity Framework 6.x stores, make sure you use the built-in ")
-                        .Append("'OpenIddictApplication' entity (from the 'OpenIddict.EntityFramework.Models' package) ")
-                        .Append("or a custom entity that inherits from the generic 'OpenIddictApplication' entity.")
+                        .Append("'OpenIddictEntityFrameworkApplication' entity or a custom entity that inherits ")
+                        .Append("from the generic 'OpenIddictEntityFrameworkApplication' entity.")
                         .ToString());
                 }
 
@@ -72,7 +72,7 @@ namespace OpenIddict.EntityFramework
                         .ToString());
                 }
 
-                return typeof(OpenIddictApplicationStore<,,,,>).MakeGenericType(
+                return typeof(OpenIddictEntityFrameworkApplicationStore<,,,,>).MakeGenericType(
                     /* TApplication: */ key,
                     /* TAuthorization: */ root.GenericTypeArguments[1],
                     /* TToken: */ root.GenericTypeArguments[2],

src/OpenIddict.EntityFramework/Resolvers/OpenIddictAuthorizationStoreResolver.cs → src/OpenIddict.EntityFramework/Resolvers/OpenIddictEntityFrameworkAuthorizationStoreResolver.cs

@@ -19,13 +19,13 @@ namespace OpenIddict.EntityFramework
     /// <summary>
     /// Exposes a method allowing to resolve an authorization store.
     /// </summary>
-    public class OpenIddictAuthorizationStoreResolver : IOpenIddictAuthorizationStoreResolver
+    public class OpenIddictEntityFrameworkAuthorizationStoreResolver : IOpenIddictAuthorizationStoreResolver
     {
         private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkOptions> _options;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictAuthorizationStoreResolver(
+        public OpenIddictEntityFrameworkAuthorizationStoreResolver(
             [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options,
             [NotNull] IServiceProvider provider)
@@ -51,14 +51,14 @@ namespace OpenIddict.EntityFramework
 
             var type = _cache.GetOrAdd(typeof(TAuthorization), key =>
             {
-                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictAuthorization<,,>));
+                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictEntityFrameworkAuthorization<,,>));
                 if (root == null)
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified authorization type is not compatible with the Entity Framework 6.x stores.")
                         .Append("When enabling the Entity Framework 6.x stores, make sure you use the built-in ")
-                        .Append("'OpenIddictAuthorization' entity (from the 'OpenIddict.EntityFramework.Models' package) ")
-                        .Append("or a custom entity that inherits from the generic 'OpenIddictAuthorization' entity.")
+                        .Append("'OpenIddictEntityFrameworkAuthorization' entity or a custom entity that inherits ")
+                        .Append("from the generic 'OpenIddictEntityFrameworkAuthorization' entity.")
                         .ToString());
                 }
 
@@ -72,7 +72,7 @@ namespace OpenIddict.EntityFramework
                         .ToString());
                 }
 
-                return typeof(OpenIddictAuthorizationStore<,,,,>).MakeGenericType(
+                return typeof(OpenIddictEntityFrameworkAuthorizationStore<,,,,>).MakeGenericType(
                     /* TAuthorization: */ key,
                     /* TApplication: */ root.GenericTypeArguments[1],
                     /* TToken: */ root.GenericTypeArguments[2],

src/OpenIddict.EntityFramework/Resolvers/OpenIddictScopeStoreResolver.cs → src/OpenIddict.EntityFramework/Resolvers/OpenIddictEntityFrameworkScopeStoreResolver.cs

@@ -19,13 +19,13 @@ namespace OpenIddict.EntityFramework
     /// <summary>
     /// Exposes a method allowing to resolve a scope store.
     /// </summary>
-    public class OpenIddictScopeStoreResolver : IOpenIddictScopeStoreResolver
+    public class OpenIddictEntityFrameworkScopeStoreResolver : IOpenIddictScopeStoreResolver
     {
         private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkOptions> _options;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictScopeStoreResolver(
+        public OpenIddictEntityFrameworkScopeStoreResolver(
             [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options,
             [NotNull] IServiceProvider provider)
@@ -51,14 +51,14 @@ namespace OpenIddict.EntityFramework
 
             var type = _cache.GetOrAdd(typeof(TScope), key =>
             {
-                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictScope<>));
+                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictEntityFrameworkScope<>));
                 if (root == null)
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified scope type is not compatible with the Entity Framework 6.x stores.")
                         .Append("When enabling the Entity Framework 6.x stores, make sure you use the built-in ")
-                        .Append("'OpenIddictScope' entity (from the 'OpenIddict.EntityFramework.Models' package) ")
-                        .Append("or a custom entity that inherits from the generic 'OpenIddictScope' entity.")
+                        .Append("'OpenIddictEntityFrameworkScope' entity or a custom entity that inherits ")
+                        .Append("from the generic 'OpenIddictEntityFrameworkScope' entity.")
                         .ToString());
                 }
 
@@ -72,7 +72,7 @@ namespace OpenIddict.EntityFramework
                         .ToString());
                 }
 
-                return typeof(OpenIddictScopeStore<,,>).MakeGenericType(
+                return typeof(OpenIddictEntityFrameworkScopeStore<,,>).MakeGenericType(
                     /* TScope: */ key,
                     /* TContext: */ context,
                     /* TKey: */ root.GenericTypeArguments[0]);

src/OpenIddict.EntityFramework/Resolvers/OpenIddictTokenStoreResolver.cs → src/OpenIddict.EntityFramework/Resolvers/OpenIddictEntityFrameworkTokenStoreResolver.cs

@@ -19,13 +19,13 @@ namespace OpenIddict.EntityFramework
     /// <summary>
     /// Exposes a method allowing to resolve a token store.
     /// </summary>
-    public class OpenIddictTokenStoreResolver : IOpenIddictTokenStoreResolver
+    public class OpenIddictEntityFrameworkTokenStoreResolver : IOpenIddictTokenStoreResolver
     {
         private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkOptions> _options;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictTokenStoreResolver(
+        public OpenIddictEntityFrameworkTokenStoreResolver(
             [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options,
             [NotNull] IServiceProvider provider)
@@ -51,14 +51,14 @@ namespace OpenIddict.EntityFramework
 
             var type = _cache.GetOrAdd(typeof(TToken), key =>
             {
-                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictToken<,,>));
+                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictEntityFrameworkToken<,,>));
                 if (root == null)
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified token type is not compatible with the Entity Framework 6.x stores.")
                         .Append("When enabling the Entity Framework 6.x stores, make sure you use the built-in ")
-                        .Append("'OpenIddictToken' entity (from the 'OpenIddict.EntityFramework.Models' package) ")
-                        .Append("or a custom entity that inherits from the generic 'OpenIddictToken' entity.")
+                        .Append("'OpenIddictEntityFrameworkToken' entity or a custom entity that inherits ")
+                        .Append("from the generic 'OpenIddictEntityFrameworkToken' entity.")
                         .ToString());
                 }
 
@@ -72,7 +72,7 @@ namespace OpenIddict.EntityFramework
                         .ToString());
                 }
 
-                return typeof(OpenIddictTokenStore<,,,,>).MakeGenericType(
+                return typeof(OpenIddictEntityFrameworkTokenStore<,,,,>).MakeGenericType(
                     /* TToken: */ key,
                     /* TApplication: */ root.GenericTypeArguments[1],
                     /* TAuthorization: */ root.GenericTypeArguments[2],

src/OpenIddict.EntityFramework/Stores/OpenIddictApplicationStore.cs → src/OpenIddict.EntityFramework/Stores/OpenIddictEntityFrameworkApplicationStore.cs

@@ -29,12 +29,13 @@ namespace OpenIddict.EntityFramework
     /// Provides methods allowing to manage the applications stored in a database.
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
-    public class OpenIddictApplicationStore<TContext> : OpenIddictApplicationStore<OpenIddictApplication,
-                                                                                   OpenIddictAuthorization,
-                                                                                   OpenIddictToken, TContext, string>
+    public class OpenIddictEntityFrameworkApplicationStore<TContext> :
+        OpenIddictEntityFrameworkApplicationStore<OpenIddictEntityFrameworkApplication,
+                                                  OpenIddictEntityFrameworkAuthorization,
+                                                  OpenIddictEntityFrameworkToken, TContext, string>
         where TContext : DbContext
     {
-        public OpenIddictApplicationStore(
+        public OpenIddictEntityFrameworkApplicationStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options)
@@ -51,14 +52,14 @@ namespace OpenIddict.EntityFramework
     /// <typeparam name="TToken">The type of the Token entity.</typeparam>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictApplicationStore<TApplication, TAuthorization, TToken, TContext, TKey> : IOpenIddictApplicationStore<TApplication>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+    public class OpenIddictEntityFrameworkApplicationStore<TApplication, TAuthorization, TToken, TContext, TKey> : IOpenIddictApplicationStore<TApplication>
+        where TApplication : OpenIddictEntityFrameworkApplication<TKey, TAuthorization, TToken>
+        where TAuthorization : OpenIddictEntityFrameworkAuthorization<TKey, TApplication, TToken>
+        where TToken : OpenIddictEntityFrameworkToken<TKey, TApplication, TAuthorization>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictApplicationStore(
+        public OpenIddictEntityFrameworkApplicationStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options)

src/OpenIddict.EntityFramework/Stores/OpenIddictAuthorizationStore.cs → src/OpenIddict.EntityFramework/Stores/OpenIddictEntityFrameworkAuthorizationStore.cs

@@ -29,12 +29,13 @@ namespace OpenIddict.EntityFramework
     /// Provides methods allowing to manage the authorizations stored in a database.
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
-    public class OpenIddictAuthorizationStore<TContext> : OpenIddictAuthorizationStore<OpenIddictAuthorization,
-                                                                                       OpenIddictApplication,
-                                                                                       OpenIddictToken, TContext, string>
+    public class OpenIddictEntityFrameworkAuthorizationStore<TContext> :
+        OpenIddictEntityFrameworkAuthorizationStore<OpenIddictEntityFrameworkAuthorization,
+                                                    OpenIddictEntityFrameworkApplication,
+                                                    OpenIddictEntityFrameworkToken, TContext, string>
         where TContext : DbContext
     {
-        public OpenIddictAuthorizationStore(
+        public OpenIddictEntityFrameworkAuthorizationStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options)
@@ -51,14 +52,14 @@ namespace OpenIddict.EntityFramework
     /// <typeparam name="TToken">The type of the Token entity.</typeparam>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictAuthorizationStore<TAuthorization, TApplication, TToken, TContext, TKey> : IOpenIddictAuthorizationStore<TAuthorization>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+    public class OpenIddictEntityFrameworkAuthorizationStore<TAuthorization, TApplication, TToken, TContext, TKey> : IOpenIddictAuthorizationStore<TAuthorization>
+        where TAuthorization : OpenIddictEntityFrameworkAuthorization<TKey, TApplication, TToken>
+        where TApplication : OpenIddictEntityFrameworkApplication<TKey, TAuthorization, TToken>
+        where TToken : OpenIddictEntityFrameworkToken<TKey, TApplication, TAuthorization>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictAuthorizationStore(
+        public OpenIddictEntityFrameworkAuthorizationStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options)

src/OpenIddict.EntityFramework/Stores/OpenIddictScopeStore.cs → src/OpenIddict.EntityFramework/Stores/OpenIddictEntityFrameworkScopeStore.cs

@@ -28,10 +28,11 @@ namespace OpenIddict.EntityFramework
     /// Provides methods allowing to manage the scopes stored in a database.
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
-    public class OpenIddictScopeStore<TContext> : OpenIddictScopeStore<OpenIddictScope, TContext, string>
+    public class OpenIddictEntityFrameworkScopeStore<TContext> :
+        OpenIddictEntityFrameworkScopeStore<OpenIddictEntityFrameworkScope, TContext, string>
         where TContext : DbContext
     {
-        public OpenIddictScopeStore(
+        public OpenIddictEntityFrameworkScopeStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options)
@@ -46,12 +47,12 @@ namespace OpenIddict.EntityFramework
     /// <typeparam name="TScope">The type of the Scope entity.</typeparam>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictScopeStore<TScope, TContext, TKey> : IOpenIddictScopeStore<TScope>
-        where TScope : OpenIddictScope<TKey>
+    public class OpenIddictEntityFrameworkScopeStore<TScope, TContext, TKey> : IOpenIddictScopeStore<TScope>
+        where TScope : OpenIddictEntityFrameworkScope<TKey>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictScopeStore(
+        public OpenIddictEntityFrameworkScopeStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options)

src/OpenIddict.EntityFramework/Stores/OpenIddictTokenStore.cs → src/OpenIddict.EntityFramework/Stores/OpenIddictEntityFrameworkTokenStore.cs

@@ -29,12 +29,13 @@ namespace OpenIddict.EntityFramework
     /// Provides methods allowing to manage the tokens stored in a database.
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
-    public class OpenIddictTokenStore<TContext> : OpenIddictTokenStore<OpenIddictToken,
-                                                                       OpenIddictApplication,
-                                                                       OpenIddictAuthorization, TContext, string>
+    public class OpenIddictEntityFrameworkTokenStore<TContext> :
+        OpenIddictEntityFrameworkTokenStore<OpenIddictEntityFrameworkToken,
+                                            OpenIddictEntityFrameworkApplication,
+                                            OpenIddictEntityFrameworkAuthorization, TContext, string>
         where TContext : DbContext
     {
-        public OpenIddictTokenStore(
+        public OpenIddictEntityFrameworkTokenStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options)
@@ -51,14 +52,14 @@ namespace OpenIddict.EntityFramework
     /// <typeparam name="TAuthorization">The type of the Authorization entity.</typeparam>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictTokenStore<TToken, TApplication, TAuthorization, TContext, TKey> : IOpenIddictTokenStore<TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
+    public class OpenIddictEntityFrameworkTokenStore<TToken, TApplication, TAuthorization, TContext, TKey> : IOpenIddictTokenStore<TToken>
+        where TToken : OpenIddictEntityFrameworkToken<TKey, TApplication, TAuthorization>
+        where TApplication : OpenIddictEntityFrameworkApplication<TKey, TAuthorization, TToken>
+        where TAuthorization : OpenIddictEntityFrameworkAuthorization<TKey, TApplication, TToken>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictTokenStore(
+        public OpenIddictEntityFrameworkTokenStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options)

src/OpenIddict.EntityFrameworkCore.Models/OpenIddictApplication.cs → src/OpenIddict.EntityFrameworkCore.Models/OpenIddictEntityFrameworkCoreApplication.cs

@@ -13,9 +13,9 @@ namespace OpenIddict.EntityFrameworkCore.Models
     /// <summary>
     /// Represents an OpenIddict application.
     /// </summary>
-    public class OpenIddictApplication : OpenIddictApplication<string, OpenIddictAuthorization, OpenIddictToken>
+    public class OpenIddictEntityFrameworkCoreApplication : OpenIddictEntityFrameworkCoreApplication<string, OpenIddictEntityFrameworkCoreAuthorization, OpenIddictEntityFrameworkCoreToken>
     {
-        public OpenIddictApplication()
+        public OpenIddictEntityFrameworkCoreApplication()
         {
             // Generate a new string identifier.
             Id = Guid.NewGuid().ToString();
@@ -25,15 +25,16 @@ namespace OpenIddict.EntityFrameworkCore.Models
     /// <summary>
     /// Represents an OpenIddict application.
     /// </summary>
-    public class OpenIddictApplication<TKey> : OpenIddictApplication<TKey, OpenIddictAuthorization<TKey>, OpenIddictToken<TKey>>
+    public class OpenIddictEntityFrameworkCoreApplication<TKey> : OpenIddictEntityFrameworkCoreApplication<TKey, OpenIddictEntityFrameworkCoreAuthorization<TKey>, OpenIddictEntityFrameworkCoreToken<TKey>>
         where TKey : IEquatable<TKey>
-    { }
+    {
+    }
 
     /// <summary>
     /// Represents an OpenIddict application.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; ClientId = {ClientId,nq} ; Type = {Type,nq}")]
-    public class OpenIddictApplication<TKey, TAuthorization, TToken> where TKey : IEquatable<TKey>
+    public class OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Gets the list of the authorizations associated with this application.

src/OpenIddict.EntityFrameworkCore.Models/OpenIddictAuthorization.cs → src/OpenIddict.EntityFrameworkCore.Models/OpenIddictEntityFrameworkCoreAuthorization.cs

@@ -13,9 +13,9 @@ namespace OpenIddict.EntityFrameworkCore.Models
     /// <summary>
     /// Represents an OpenIddict authorization.
     /// </summary>
-    public class OpenIddictAuthorization : OpenIddictAuthorization<string, OpenIddictApplication, OpenIddictToken>
+    public class OpenIddictEntityFrameworkCoreAuthorization : OpenIddictEntityFrameworkCoreAuthorization<string, OpenIddictEntityFrameworkCoreApplication, OpenIddictEntityFrameworkCoreToken>
     {
-        public OpenIddictAuthorization()
+        public OpenIddictEntityFrameworkCoreAuthorization()
         {
             // Generate a new string identifier.
             Id = Guid.NewGuid().ToString();
@@ -25,15 +25,16 @@ namespace OpenIddict.EntityFrameworkCore.Models
     /// <summary>
     /// Represents an OpenIddict authorization.
     /// </summary>
-    public class OpenIddictAuthorization<TKey> : OpenIddictAuthorization<TKey, OpenIddictApplication<TKey>, OpenIddictToken<TKey>>
+    public class OpenIddictEntityFrameworkCoreAuthorization<TKey> : OpenIddictEntityFrameworkCoreAuthorization<TKey, OpenIddictEntityFrameworkCoreApplication<TKey>, OpenIddictEntityFrameworkCoreToken<TKey>>
         where TKey : IEquatable<TKey>
-    { }
+    {
+    }
 
     /// <summary>
     /// Represents an OpenIddict authorization.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; Subject = {Subject,nq} ; Type = {Type,nq} ; Status = {Status,nq}")]
-    public class OpenIddictAuthorization<TKey, TApplication, TToken> where TKey : IEquatable<TKey>
+    public class OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Gets or sets the application associated with the current authorization.

src/OpenIddict.EntityFrameworkCore.Models/OpenIddictScope.cs → src/OpenIddict.EntityFrameworkCore.Models/OpenIddictEntityFrameworkCoreScope.cs

@@ -12,9 +12,9 @@ namespace OpenIddict.EntityFrameworkCore.Models
     /// <summary>
     /// Represents an OpenIddict scope.
     /// </summary>
-    public class OpenIddictScope : OpenIddictScope<string>
+    public class OpenIddictEntityFrameworkCoreScope : OpenIddictEntityFrameworkCoreScope<string>
     {
-        public OpenIddictScope()
+        public OpenIddictEntityFrameworkCoreScope()
         {
             // Generate a new string identifier.
             Id = Guid.NewGuid().ToString();
@@ -25,7 +25,7 @@ namespace OpenIddict.EntityFrameworkCore.Models
     /// Represents an OpenIddict scope.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; Name = {Name,nq}")]
-    public class OpenIddictScope<TKey> where TKey : IEquatable<TKey>
+    public class OpenIddictEntityFrameworkCoreScope<TKey> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Gets or sets the concurrency token.

src/OpenIddict.EntityFrameworkCore.Models/OpenIddictToken.cs → src/OpenIddict.EntityFrameworkCore.Models/OpenIddictEntityFrameworkCoreToken.cs

@@ -12,9 +12,9 @@ namespace OpenIddict.EntityFrameworkCore.Models
     /// <summary>
     /// Represents an OpenIddict token.
     /// </summary>
-    public class OpenIddictToken : OpenIddictToken<string, OpenIddictApplication, OpenIddictAuthorization>
+    public class OpenIddictEntityFrameworkCoreToken : OpenIddictEntityFrameworkCoreToken<string, OpenIddictEntityFrameworkCoreApplication, OpenIddictEntityFrameworkCoreAuthorization>
     {
-        public OpenIddictToken()
+        public OpenIddictEntityFrameworkCoreToken()
         {
             // Generate a new string identifier.
             Id = Guid.NewGuid().ToString();
@@ -24,7 +24,7 @@ namespace OpenIddict.EntityFrameworkCore.Models
     /// <summary>
     /// Represents an OpenIddict token.
     /// </summary>
-    public class OpenIddictToken<TKey> : OpenIddictToken<TKey, OpenIddictApplication<TKey>, OpenIddictAuthorization<TKey>>
+    public class OpenIddictEntityFrameworkCoreToken<TKey> : OpenIddictEntityFrameworkCoreToken<TKey, OpenIddictEntityFrameworkCoreApplication<TKey>, OpenIddictEntityFrameworkCoreAuthorization<TKey>>
         where TKey : IEquatable<TKey>
     {
     }
@@ -33,7 +33,7 @@ namespace OpenIddict.EntityFrameworkCore.Models
     /// Represents an OpenIddict token.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; Subject = {Subject,nq} ; Type = {Type,nq} ; Status = {Status,nq}")]
-    public class OpenIddictToken<TKey, TApplication, TAuthorization> where TKey : IEquatable<TKey>
+    public class OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization> where TKey : IEquatable<TKey>
     {
         /// <summary>
         /// Gets or sets the application associated with the current token.

src/OpenIddict.EntityFrameworkCore/Configurations/OpenIddictApplicationConfiguration.cs → src/OpenIddict.EntityFrameworkCore/Configurations/OpenIddictEntityFrameworkCoreApplicationConfiguration.cs

@@ -21,10 +21,10 @@ namespace OpenIddict.EntityFrameworkCore
     /// <typeparam name="TToken">The type of the Token entity.</typeparam>
     /// <typeparam name="TKey">The type of the Key entity.</typeparam>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public class OpenIddictApplicationConfiguration<TApplication, TAuthorization, TToken, TKey> : IEntityTypeConfiguration<TApplication>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+    public class OpenIddictEntityFrameworkCoreApplicationConfiguration<TApplication, TAuthorization, TToken, TKey> : IEntityTypeConfiguration<TApplication>
+        where TApplication : OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken>
+        where TAuthorization : OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken>
+        where TToken : OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization>
         where TKey : IEquatable<TKey>
     {
         public void Configure([NotNull] EntityTypeBuilder<TApplication> builder)
@@ -43,7 +43,7 @@ namespace OpenIddict.EntityFrameworkCore
             // Warning: the non-generic overlord is deliberately used to work around
             // a breaking change introduced in Entity Framework Core 3.x (where a
             // generic entity type builder is now returned by the HasIndex() method).
-            builder.HasIndex(nameof(OpenIddictApplication.ClientId))
+            builder.HasIndex(nameof(OpenIddictEntityFrameworkCoreApplication.ClientId))
                    .IsUnique();
 
             builder.Property(application => application.ClientId)
@@ -63,12 +63,13 @@ namespace OpenIddict.EntityFrameworkCore
 
             builder.HasMany(application => application.Authorizations)
                    .WithOne(authorization => authorization.Application)
-                   .HasForeignKey(nameof(OpenIddictAuthorization.Application) + nameof(OpenIddictApplication.Id))
+                   .HasForeignKey(nameof(OpenIddictEntityFrameworkCoreAuthorization.Application) +
+                                  nameof(OpenIddictEntityFrameworkCoreApplication.Id))
                    .IsRequired(required: false);
 
             builder.HasMany(application => application.Tokens)
                    .WithOne(token => token.Application)
-                   .HasForeignKey(nameof(OpenIddictToken.Application) + nameof(OpenIddictApplication.Id))
+                   .HasForeignKey(nameof(OpenIddictEntityFrameworkCoreToken.Application) + nameof(OpenIddictEntityFrameworkCoreApplication.Id))
                    .IsRequired(required: false);
 
             builder.ToTable("OpenIddictApplications");

src/OpenIddict.EntityFrameworkCore/Configurations/OpenIddictAuthorizationConfiguration.cs → src/OpenIddict.EntityFrameworkCore/Configurations/OpenIddictEntityFrameworkCoreAuthorizationConfiguration.cs

@@ -21,10 +21,10 @@ namespace OpenIddict.EntityFrameworkCore
     /// <typeparam name="TToken">The type of the Token entity.</typeparam>
     /// <typeparam name="TKey">The type of the Key entity.</typeparam>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public class OpenIddictAuthorizationConfiguration<TAuthorization, TApplication, TToken, TKey> : IEntityTypeConfiguration<TAuthorization>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+    public class OpenIddictEntityFrameworkCoreAuthorizationConfiguration<TAuthorization, TApplication, TToken, TKey> : IEntityTypeConfiguration<TAuthorization>
+        where TAuthorization : OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken>
+        where TApplication : OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken>
+        where TToken : OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization>
         where TKey : IEquatable<TKey>
     {
         public void Configure([NotNull] EntityTypeBuilder<TAuthorization> builder)
@@ -41,10 +41,10 @@ namespace OpenIddict.EntityFrameworkCore
             builder.HasKey(authorization => authorization.Id);
 
             builder.HasIndex(
-                nameof(OpenIddictAuthorization.Application) + nameof(OpenIddictApplication.Id),
-                nameof(OpenIddictAuthorization.Status),
-                nameof(OpenIddictAuthorization.Subject),
-                nameof(OpenIddictAuthorization.Type));
+                nameof(OpenIddictEntityFrameworkCoreAuthorization.Application) + nameof(OpenIddictEntityFrameworkCoreApplication.Id),
+                nameof(OpenIddictEntityFrameworkCoreAuthorization.Status),
+                nameof(OpenIddictEntityFrameworkCoreAuthorization.Subject),
+                nameof(OpenIddictEntityFrameworkCoreAuthorization.Type));
 
             builder.Property(authorization => authorization.ConcurrencyToken)
                    .HasMaxLength(50)
@@ -66,7 +66,8 @@ namespace OpenIddict.EntityFrameworkCore
 
             builder.HasMany(authorization => authorization.Tokens)
                    .WithOne(token => token.Authorization)
-                   .HasForeignKey(nameof(OpenIddictToken.Authorization) + nameof(OpenIddictAuthorization.Id))
+                   .HasForeignKey(nameof(OpenIddictEntityFrameworkCoreToken.Authorization) +
+                                  nameof(OpenIddictEntityFrameworkCoreAuthorization.Id))
                    .IsRequired(required: false);
 
             builder.ToTable("OpenIddictAuthorizations");

src/OpenIddict.EntityFrameworkCore/Configurations/OpenIddictScopeConfiguration.cs → src/OpenIddict.EntityFrameworkCore/Configurations/OpenIddictEntityFrameworkCoreScopeConfiguration.cs

@@ -19,8 +19,8 @@ namespace OpenIddict.EntityFrameworkCore
     /// <typeparam name="TScope">The type of the Scope entity.</typeparam>
     /// <typeparam name="TKey">The type of the Key entity.</typeparam>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public class OpenIddictScopeConfiguration<TScope, TKey> : IEntityTypeConfiguration<TScope>
-        where TScope : OpenIddictScope<TKey>
+    public class OpenIddictEntityFrameworkCoreScopeConfiguration<TScope, TKey> : IEntityTypeConfiguration<TScope>
+        where TScope : OpenIddictEntityFrameworkCoreScope<TKey>
         where TKey : IEquatable<TKey>
     {
         public void Configure([NotNull] EntityTypeBuilder<TScope> builder)
@@ -39,7 +39,7 @@ namespace OpenIddict.EntityFrameworkCore
             // Warning: the non-generic overlord is deliberately used to work around
             // a breaking change introduced in Entity Framework Core 3.x (where a
             // generic entity type builder is now returned by the HasIndex() method).
-            builder.HasIndex(nameof(OpenIddictScope.Name))
+            builder.HasIndex(nameof(OpenIddictEntityFrameworkCoreScope.Name))
                    .IsUnique();
 
             builder.Property(scope => scope.ConcurrencyToken)

src/OpenIddict.EntityFrameworkCore/Configurations/OpenIddictTokenConfiguration.cs → src/OpenIddict.EntityFrameworkCore/Configurations/OpenIddictEntityFrameworkCoreTokenConfiguration.cs

@@ -21,10 +21,10 @@ namespace OpenIddict.EntityFrameworkCore
     /// <typeparam name="TAuthorization">The type of the Authorization entity.</typeparam>
     /// <typeparam name="TKey">The type of the Key entity.</typeparam>
     [EditorBrowsable(EditorBrowsableState.Never)]
-    public class OpenIddictTokenConfiguration<TToken, TApplication, TAuthorization, TKey> : IEntityTypeConfiguration<TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
+    public class OpenIddictEntityFrameworkCoreTokenConfiguration<TToken, TApplication, TAuthorization, TKey> : IEntityTypeConfiguration<TToken>
+        where TToken : OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization>
+        where TApplication : OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken>
+        where TAuthorization : OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken>
         where TKey : IEquatable<TKey>
     {
         public void Configure([NotNull] EntityTypeBuilder<TToken> builder)
@@ -43,14 +43,14 @@ namespace OpenIddict.EntityFrameworkCore
             // Warning: the non-generic overlord is deliberately used to work around
             // a breaking change introduced in Entity Framework Core 3.x (where a
             // generic entity type builder is now returned by the HasIndex() method).
-            builder.HasIndex(nameof(OpenIddictToken.ReferenceId))
+            builder.HasIndex(nameof(OpenIddictEntityFrameworkCoreToken.ReferenceId))
                    .IsUnique();
 
             builder.HasIndex(
-                nameof(OpenIddictToken.Application) + nameof(OpenIddictApplication.Id),
-                nameof(OpenIddictToken.Status),
-                nameof(OpenIddictToken.Subject),
-                nameof(OpenIddictToken.Type));
+                nameof(OpenIddictEntityFrameworkCoreToken.Application) + nameof(OpenIddictEntityFrameworkCoreApplication.Id),
+                nameof(OpenIddictEntityFrameworkCoreToken.Status),
+                nameof(OpenIddictEntityFrameworkCoreToken.Subject),
+                nameof(OpenIddictEntityFrameworkCoreToken.Type));
 
             builder.Property(token => token.ConcurrencyToken)
                    .HasMaxLength(50)

src/OpenIddict.EntityFrameworkCore/OpenIddictEntityFrameworkCoreBuilder.cs

@@ -57,10 +57,10 @@ namespace Microsoft.Extensions.DependencyInjection
         /// <returns>The <see cref="OpenIddictEntityFrameworkCoreBuilder"/>.</returns>
         public OpenIddictEntityFrameworkCoreBuilder ReplaceDefaultEntities<TKey>()
             where TKey : IEquatable<TKey>
-            => ReplaceDefaultEntities<OpenIddictApplication<TKey>,
-                                      OpenIddictAuthorization<TKey>,
-                                      OpenIddictScope<TKey>,
-                                      OpenIddictToken<TKey>, TKey>();
+            => ReplaceDefaultEntities<OpenIddictEntityFrameworkCoreApplication<TKey>,
+                                      OpenIddictEntityFrameworkCoreAuthorization<TKey>,
+                                      OpenIddictEntityFrameworkCoreScope<TKey>,
+                                      OpenIddictEntityFrameworkCoreToken<TKey>, TKey>();
 
         /// <summary>
         /// Configures OpenIddict to use the specified entities, derived
@@ -68,10 +68,10 @@ namespace Microsoft.Extensions.DependencyInjection
         /// </summary>
         /// <returns>The <see cref="OpenIddictEntityFrameworkCoreBuilder"/>.</returns>
         public OpenIddictEntityFrameworkCoreBuilder ReplaceDefaultEntities<TApplication, TAuthorization, TScope, TToken, TKey>()
-            where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-            where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-            where TScope : OpenIddictScope<TKey>
-            where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+            where TApplication : OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken>
+            where TAuthorization : OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken>
+            where TScope : OpenIddictEntityFrameworkCoreScope<TKey>
+            where TToken : OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization>
             where TKey : IEquatable<TKey>
         {
             Services.Configure<OpenIddictCoreOptions>(options =>

src/OpenIddict.EntityFrameworkCore/OpenIddictEntityFrameworkCoreCustomizer.cs

@@ -17,10 +17,10 @@ namespace OpenIddict.EntityFrameworkCore
     /// required by the OpenIddict stack in an Entity Framework Core context.
     /// </summary>
     public class OpenIddictEntityFrameworkCoreCustomizer<TApplication, TAuthorization, TScope, TToken, TKey> : RelationalModelCustomizer
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-        where TScope : OpenIddictScope<TKey>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+        where TApplication : OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken>
+        where TAuthorization : OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken>
+        where TScope : OpenIddictEntityFrameworkCoreScope<TKey>
+        where TToken : OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization>
         where TKey : IEquatable<TKey>
     {
         public OpenIddictEntityFrameworkCoreCustomizer([NotNull] ModelCustomizerDependencies dependencies)

src/OpenIddict.EntityFrameworkCore/OpenIddictEntityFrameworkCoreExtensions.cs

@@ -36,25 +36,25 @@ namespace Microsoft.Extensions.DependencyInjection
             // in case case-sensitive stores were registered before this extension was called.
             builder.Configure(options => options.DisableAdditionalFiltering = false);
 
-            builder.SetDefaultApplicationEntity<OpenIddictApplication>()
-                   .SetDefaultAuthorizationEntity<OpenIddictAuthorization>()
-                   .SetDefaultScopeEntity<OpenIddictScope>()
-                   .SetDefaultTokenEntity<OpenIddictToken>();
+            builder.SetDefaultApplicationEntity<OpenIddictEntityFrameworkCoreApplication>()
+                   .SetDefaultAuthorizationEntity<OpenIddictEntityFrameworkCoreAuthorization>()
+                   .SetDefaultScopeEntity<OpenIddictEntityFrameworkCoreScope>()
+                   .SetDefaultTokenEntity<OpenIddictEntityFrameworkCoreToken>();
 
-            builder.ReplaceApplicationStoreResolver<OpenIddictApplicationStoreResolver>()
-                   .ReplaceAuthorizationStoreResolver<OpenIddictAuthorizationStoreResolver>()
-                   .ReplaceScopeStoreResolver<OpenIddictScopeStoreResolver>()
-                   .ReplaceTokenStoreResolver<OpenIddictTokenStoreResolver>();
+            builder.ReplaceApplicationStoreResolver<OpenIddictEntityFrameworkCoreApplicationStoreResolver>()
+                   .ReplaceAuthorizationStoreResolver<OpenIddictEntityFrameworkCoreAuthorizationStoreResolver>()
+                   .ReplaceScopeStoreResolver<OpenIddictEntityFrameworkCoreScopeStoreResolver>()
+                   .ReplaceTokenStoreResolver<OpenIddictEntityFrameworkCoreTokenStoreResolver>();
 
-            builder.Services.TryAddSingleton<OpenIddictApplicationStoreResolver.TypeResolutionCache>();
-            builder.Services.TryAddSingleton<OpenIddictAuthorizationStoreResolver.TypeResolutionCache>();
-            builder.Services.TryAddSingleton<OpenIddictScopeStoreResolver.TypeResolutionCache>();
-            builder.Services.TryAddSingleton<OpenIddictTokenStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictEntityFrameworkCoreApplicationStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictEntityFrameworkCoreAuthorizationStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictEntityFrameworkCoreScopeStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictEntityFrameworkCoreTokenStoreResolver.TypeResolutionCache>();
 
-            builder.Services.TryAddScoped(typeof(OpenIddictApplicationStore<,,,,>));
-            builder.Services.TryAddScoped(typeof(OpenIddictAuthorizationStore<,,,,>));
-            builder.Services.TryAddScoped(typeof(OpenIddictScopeStore<,,>));
-            builder.Services.TryAddScoped(typeof(OpenIddictTokenStore<,,,,>));
+            builder.Services.TryAddScoped(typeof(OpenIddictEntityFrameworkCoreApplicationStore<,,,,>));
+            builder.Services.TryAddScoped(typeof(OpenIddictEntityFrameworkCoreAuthorizationStore<,,,,>));
+            builder.Services.TryAddScoped(typeof(OpenIddictEntityFrameworkCoreScopeStore<,,>));
+            builder.Services.TryAddScoped(typeof(OpenIddictEntityFrameworkCoreTokenStore<,,,,>));
 
             return new OpenIddictEntityFrameworkCoreBuilder(builder.Services);
         }

src/OpenIddict.EntityFrameworkCore/OpenIddictEntityFrameworkCoreHelpers.cs

@@ -28,10 +28,10 @@ namespace Microsoft.EntityFrameworkCore
         /// <param name="builder">The builder used to configure the Entity Framework context.</param>
         /// <returns>The Entity Framework context builder.</returns>
         public static DbContextOptionsBuilder UseOpenIddict([NotNull] this DbContextOptionsBuilder builder)
-            => builder.UseOpenIddict<OpenIddictApplication,
-                                     OpenIddictAuthorization,
-                                     OpenIddictScope,
-                                     OpenIddictToken, string>();
+            => builder.UseOpenIddict<OpenIddictEntityFrameworkCoreApplication,
+                                     OpenIddictEntityFrameworkCoreAuthorization,
+                                     OpenIddictEntityFrameworkCoreScope,
+                                     OpenIddictEntityFrameworkCoreToken, string>();
 
         /// <summary>
         /// Registers the OpenIddict entity sets in the Entity Framework Core 
@@ -41,10 +41,10 @@ namespace Microsoft.EntityFrameworkCore
         /// <returns>The Entity Framework context builder.</returns>
         public static DbContextOptionsBuilder UseOpenIddict<TKey>([NotNull] this DbContextOptionsBuilder builder)
             where TKey : IEquatable<TKey>
-            => builder.UseOpenIddict<OpenIddictApplication<TKey>,
-                                     OpenIddictAuthorization<TKey>,
-                                     OpenIddictScope<TKey>,
-                                     OpenIddictToken<TKey>, TKey>();
+            => builder.UseOpenIddict<OpenIddictEntityFrameworkCoreApplication<TKey>,
+                                     OpenIddictEntityFrameworkCoreAuthorization<TKey>,
+                                     OpenIddictEntityFrameworkCoreScope<TKey>,
+                                     OpenIddictEntityFrameworkCoreToken<TKey>, TKey>();
 
         /// <summary>
         /// Registers the OpenIddict entity sets in the Entity Framework Core
@@ -53,10 +53,10 @@ namespace Microsoft.EntityFrameworkCore
         /// <param name="builder">The builder used to configure the Entity Framework context.</param>
         /// <returns>The Entity Framework context builder.</returns>
         public static DbContextOptionsBuilder UseOpenIddict<TApplication, TAuthorization, TScope, TToken, TKey>([NotNull] this DbContextOptionsBuilder builder)
-            where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-            where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-            where TScope : OpenIddictScope<TKey>
-            where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+            where TApplication : OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken>
+            where TAuthorization : OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken>
+            where TScope : OpenIddictEntityFrameworkCoreScope<TKey>
+            where TToken : OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization>
             where TKey : IEquatable<TKey>
         {
             if (builder == null)
@@ -75,10 +75,10 @@ namespace Microsoft.EntityFrameworkCore
         /// <param name="builder">The builder used to configure the Entity Framework context.</param>
         /// <returns>The Entity Framework context builder.</returns>
         public static ModelBuilder UseOpenIddict([NotNull] this ModelBuilder builder)
-            => builder.UseOpenIddict<OpenIddictApplication,
-                                     OpenIddictAuthorization,
-                                     OpenIddictScope,
-                                     OpenIddictToken, string>();
+            => builder.UseOpenIddict<OpenIddictEntityFrameworkCoreApplication,
+                                     OpenIddictEntityFrameworkCoreAuthorization,
+                                     OpenIddictEntityFrameworkCoreScope,
+                                     OpenIddictEntityFrameworkCoreToken, string>();
 
         /// <summary>
         /// Registers the OpenIddict entity sets in the Entity Framework Core
@@ -87,10 +87,10 @@ namespace Microsoft.EntityFrameworkCore
         /// <param name="builder">The builder used to configure the Entity Framework context.</param>
         /// <returns>The Entity Framework context builder.</returns>
         public static ModelBuilder UseOpenIddict<TKey>([NotNull] this ModelBuilder builder) where TKey : IEquatable<TKey>
-            => builder.UseOpenIddict<OpenIddictApplication<TKey>,
-                                     OpenIddictAuthorization<TKey>,
-                                     OpenIddictScope<TKey>,
-                                     OpenIddictToken<TKey>, TKey>();
+            => builder.UseOpenIddict<OpenIddictEntityFrameworkCoreApplication<TKey>,
+                                     OpenIddictEntityFrameworkCoreAuthorization<TKey>,
+                                     OpenIddictEntityFrameworkCoreScope<TKey>,
+                                     OpenIddictEntityFrameworkCoreToken<TKey>, TKey>();
 
         /// <summary>
         /// Registers the OpenIddict entity sets in the Entity Framework Core
@@ -99,10 +99,10 @@ namespace Microsoft.EntityFrameworkCore
         /// <param name="builder">The builder used to configure the Entity Framework context.</param>
         /// <returns>The Entity Framework context builder.</returns>
         public static ModelBuilder UseOpenIddict<TApplication, TAuthorization, TScope, TToken, TKey>([NotNull] this ModelBuilder builder)
-            where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-            where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-            where TScope : OpenIddictScope<TKey>
-            where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+            where TApplication : OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken>
+            where TAuthorization : OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken>
+            where TScope : OpenIddictEntityFrameworkCoreScope<TKey>
+            where TToken : OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization>
             where TKey : IEquatable<TKey>
         {
             if (builder == null)
@@ -111,10 +111,10 @@ namespace Microsoft.EntityFrameworkCore
             }
 
             return builder
-                .ApplyConfiguration(new OpenIddictApplicationConfiguration<TApplication, TAuthorization, TToken, TKey>())
-                .ApplyConfiguration(new OpenIddictAuthorizationConfiguration<TAuthorization, TApplication, TToken, TKey>())
-                .ApplyConfiguration(new OpenIddictScopeConfiguration<TScope, TKey>())
-                .ApplyConfiguration(new OpenIddictTokenConfiguration<TToken, TApplication, TAuthorization, TKey>());
+                .ApplyConfiguration(new OpenIddictEntityFrameworkCoreApplicationConfiguration<TApplication, TAuthorization, TToken, TKey>())
+                .ApplyConfiguration(new OpenIddictEntityFrameworkCoreAuthorizationConfiguration<TAuthorization, TApplication, TToken, TKey>())
+                .ApplyConfiguration(new OpenIddictEntityFrameworkCoreScopeConfiguration<TScope, TKey>())
+                .ApplyConfiguration(new OpenIddictEntityFrameworkCoreTokenConfiguration<TToken, TApplication, TAuthorization, TKey>());
         }
 
 #if !SUPPORTS_BCL_ASYNC_ENUMERABLE

src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictApplicationStoreResolver.cs → src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictEntityFrameworkCoreApplicationStoreResolver.cs

@@ -19,13 +19,13 @@ namespace OpenIddict.EntityFrameworkCore
     /// <summary>
     /// Exposes a method allowing to resolve an application store.
     /// </summary>
-    public class OpenIddictApplicationStoreResolver : IOpenIddictApplicationStoreResolver
+    public class OpenIddictEntityFrameworkCoreApplicationStoreResolver : IOpenIddictApplicationStoreResolver
     {
         private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> _options;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictApplicationStoreResolver(
+        public OpenIddictEntityFrameworkCoreApplicationStoreResolver(
             [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options,
             [NotNull] IServiceProvider provider)
@@ -51,14 +51,14 @@ namespace OpenIddict.EntityFrameworkCore
 
             var type = _cache.GetOrAdd(typeof(TApplication), key =>
             {
-                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictApplication<,,>));
+                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictEntityFrameworkCoreApplication<,,>));
                 if (root == null)
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified application type is not compatible with the Entity Framework Core stores.")
                         .Append("When enabling the Entity Framework Core stores, make sure you use the built-in ")
-                        .Append("'OpenIddictApplication' entity (from the 'OpenIddict.EntityFrameworkCore.Models' package) ")
-                        .Append("or a custom entity that inherits from the generic 'OpenIddictApplication' entity.")
+                        .Append("'OpenIddictEntityFrameworkCoreApplication' entity or a custom entity that inherits ")
+                        .Append("from the generic 'OpenIddictEntityFrameworkCoreApplication' entity.")
                         .ToString());
                 }
 
@@ -72,7 +72,7 @@ namespace OpenIddict.EntityFrameworkCore
                         .ToString());
                 }
 
-                return typeof(OpenIddictApplicationStore<,,,,>).MakeGenericType(
+                return typeof(OpenIddictEntityFrameworkCoreApplicationStore<,,,,>).MakeGenericType(
                     /* TApplication: */ key,
                     /* TAuthorization: */ root.GenericTypeArguments[1],
                     /* TToken: */ root.GenericTypeArguments[2],

src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictAuthorizationStoreResolver.cs → src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictEntityFrameworkCoreAuthorizationStoreResolver.cs

@@ -19,13 +19,13 @@ namespace OpenIddict.EntityFrameworkCore
     /// <summary>
     /// Exposes a method allowing to resolve an authorization store.
     /// </summary>
-    public class OpenIddictAuthorizationStoreResolver : IOpenIddictAuthorizationStoreResolver
+    public class OpenIddictEntityFrameworkCoreAuthorizationStoreResolver : IOpenIddictAuthorizationStoreResolver
     {
         private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> _options;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictAuthorizationStoreResolver(
+        public OpenIddictEntityFrameworkCoreAuthorizationStoreResolver(
             [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options,
             [NotNull] IServiceProvider provider)
@@ -51,14 +51,14 @@ namespace OpenIddict.EntityFrameworkCore
 
             var type = _cache.GetOrAdd(typeof(TAuthorization), key =>
             {
-                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictAuthorization<,,>));
+                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictEntityFrameworkCoreAuthorization<,,>));
                 if (root == null)
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified authorization type is not compatible with the Entity Framework Core stores.")
                         .Append("When enabling the Entity Framework Core stores, make sure you use the built-in ")
-                        .Append("'OpenIddictAuthorization' entity (from the 'OpenIddict.EntityFrameworkCore.Models' package) ")
-                        .Append("or a custom entity that inherits from the generic 'OpenIddictAuthorization' entity.")
+                        .Append("'OpenIddictEntityFrameworkCoreAuthorization' entity or a custom entity that inherits ")
+                        .Append("from the generic 'OpenIddictEntityFrameworkCoreAuthorization' entity.")
                         .ToString());
                 }
 
@@ -72,7 +72,7 @@ namespace OpenIddict.EntityFrameworkCore
                         .ToString());
                 }
 
-                return typeof(OpenIddictAuthorizationStore<,,,,>).MakeGenericType(
+                return typeof(OpenIddictEntityFrameworkCoreAuthorizationStore<,,,,>).MakeGenericType(
                     /* TAuthorization: */ key,
                     /* TApplication: */ root.GenericTypeArguments[1],
                     /* TToken: */ root.GenericTypeArguments[2],

src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictScopeStoreResolver.cs → src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictEntityFrameworkCoreScopeStoreResolver.cs

@@ -19,13 +19,13 @@ namespace OpenIddict.EntityFrameworkCore
     /// <summary>
     /// Exposes a method allowing to resolve a scope store.
     /// </summary>
-    public class OpenIddictScopeStoreResolver : IOpenIddictScopeStoreResolver
+    public class OpenIddictEntityFrameworkCoreScopeStoreResolver : IOpenIddictScopeStoreResolver
     {
         private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> _options;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictScopeStoreResolver(
+        public OpenIddictEntityFrameworkCoreScopeStoreResolver(
             [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options,
             [NotNull] IServiceProvider provider)
@@ -51,14 +51,14 @@ namespace OpenIddict.EntityFrameworkCore
 
             var type = _cache.GetOrAdd(typeof(TScope), key =>
             {
-                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictScope<>));
+                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictEntityFrameworkCoreScope<>));
                 if (root == null)
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified scope type is not compatible with the Entity Framework Core stores.")
                         .Append("When enabling the Entity Framework Core stores, make sure you use the built-in ")
-                        .Append("'OpenIddictScope' entity (from the 'OpenIddict.EntityFrameworkCore.Models' package) ")
-                        .Append("or a custom entity that inherits from the generic 'OpenIddictScope' entity.")
+                        .Append("'OpenIddictEntityFrameworkCoreScope' entity or a custom entity that inherits ")
+                        .Append("from the generic 'OpenIddictEntityFrameworkCoreScope' entity.")
                         .ToString());
                 }
 
@@ -72,7 +72,7 @@ namespace OpenIddict.EntityFrameworkCore
                         .ToString());
                 }
 
-                return typeof(OpenIddictScopeStore<,,>).MakeGenericType(
+                return typeof(OpenIddictEntityFrameworkCoreScopeStore<,,>).MakeGenericType(
                     /* TScope: */ key,
                     /* TContext: */ context,
                     /* TKey: */ root.GenericTypeArguments[0]);

src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictTokenStoreResolver.cs → src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictEntityFrameworkCoreTokenStoreResolver.cs

@@ -19,13 +19,13 @@ namespace OpenIddict.EntityFrameworkCore
     /// <summary>
     /// Exposes a method allowing to resolve a token store.
     /// </summary>
-    public class OpenIddictTokenStoreResolver : IOpenIddictTokenStoreResolver
+    public class OpenIddictEntityFrameworkCoreTokenStoreResolver : IOpenIddictTokenStoreResolver
     {
         private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> _options;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictTokenStoreResolver(
+        public OpenIddictEntityFrameworkCoreTokenStoreResolver(
             [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options,
             [NotNull] IServiceProvider provider)
@@ -51,14 +51,14 @@ namespace OpenIddict.EntityFrameworkCore
 
             var type = _cache.GetOrAdd(typeof(TToken), key =>
             {
-                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictToken<,,>));
+                var root = OpenIddictHelpers.FindGenericBaseType(key, typeof(OpenIddictEntityFrameworkCoreToken<,,>));
                 if (root == null)
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified token type is not compatible with the Entity Framework Core stores.")
                         .Append("When enabling the Entity Framework Core stores, make sure you use the built-in ")
-                        .Append("'OpenIddictToken' entity (from the 'OpenIddict.EntityFrameworkCore.Models' package) ")
-                        .Append("or a custom entity that inherits from the generic 'OpenIddictToken' entity.")
+                        .Append("'OpenIddictEntityFrameworkCoreToken' entity or a custom entity that inherits ")
+                        .Append("from the generic 'OpenIddictEntityFrameworkCoreToken' entity.")
                         .ToString());
                 }
 
@@ -72,7 +72,7 @@ namespace OpenIddict.EntityFrameworkCore
                         .ToString());
                 }
 
-                return typeof(OpenIddictTokenStore<,,,,>).MakeGenericType(
+                return typeof(OpenIddictEntityFrameworkCoreTokenStore<,,,,>).MakeGenericType(
                     /* TToken: */ key,
                     /* TApplication: */ root.GenericTypeArguments[1],
                     /* TAuthorization: */ root.GenericTypeArguments[2],

src/OpenIddict.EntityFrameworkCore/Stores/OpenIddictApplicationStore.cs → src/OpenIddict.EntityFrameworkCore/Stores/OpenIddictEntityFrameworkCoreApplicationStore.cs

@@ -30,12 +30,13 @@ namespace OpenIddict.EntityFrameworkCore
     /// Provides methods allowing to manage the applications stored in a database.
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
-    public class OpenIddictApplicationStore<TContext> : OpenIddictApplicationStore<OpenIddictApplication,
-                                                                                   OpenIddictAuthorization,
-                                                                                   OpenIddictToken, TContext, string>
+    public class OpenIddictEntityFrameworkCoreApplicationStore<TContext> :
+        OpenIddictEntityFrameworkCoreApplicationStore<OpenIddictEntityFrameworkCoreApplication,
+                                                      OpenIddictEntityFrameworkCoreAuthorization,
+                                                      OpenIddictEntityFrameworkCoreToken, TContext, string>
         where TContext : DbContext
     {
-        public OpenIddictApplicationStore(
+        public OpenIddictEntityFrameworkCoreApplicationStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)
@@ -49,13 +50,14 @@ namespace OpenIddict.EntityFrameworkCore
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictApplicationStore<TContext, TKey> : OpenIddictApplicationStore<OpenIddictApplication<TKey>,
-                                                                                         OpenIddictAuthorization<TKey>,
-                                                                                         OpenIddictToken<TKey>, TContext, TKey>
+    public class OpenIddictEntityFrameworkCoreApplicationStore<TContext, TKey> :
+        OpenIddictEntityFrameworkCoreApplicationStore<OpenIddictEntityFrameworkCoreApplication<TKey>,
+                                                      OpenIddictEntityFrameworkCoreAuthorization<TKey>,
+                                                      OpenIddictEntityFrameworkCoreToken<TKey>, TContext, TKey>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictApplicationStore(
+        public OpenIddictEntityFrameworkCoreApplicationStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)
@@ -72,14 +74,14 @@ namespace OpenIddict.EntityFrameworkCore
     /// <typeparam name="TToken">The type of the Token entity.</typeparam>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictApplicationStore<TApplication, TAuthorization, TToken, TContext, TKey> : IOpenIddictApplicationStore<TApplication>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+    public class OpenIddictEntityFrameworkCoreApplicationStore<TApplication, TAuthorization, TToken, TContext, TKey> : IOpenIddictApplicationStore<TApplication>
+        where TApplication : OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken>
+        where TAuthorization : OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken>
+        where TToken : OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictApplicationStore(
+        public OpenIddictEntityFrameworkCoreApplicationStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)

src/OpenIddict.EntityFrameworkCore/Stores/OpenIddictAuthorizationStore.cs → src/OpenIddict.EntityFrameworkCore/Stores/OpenIddictEntityFrameworkCoreAuthorizationStore.cs

@@ -30,12 +30,13 @@ namespace OpenIddict.EntityFrameworkCore
     /// Provides methods allowing to manage the authorizations stored in a database.
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
-    public class OpenIddictAuthorizationStore<TContext> : OpenIddictAuthorizationStore<OpenIddictAuthorization,
-                                                                                       OpenIddictApplication,
-                                                                                       OpenIddictToken, TContext, string>
+    public class OpenIddictEntityFrameworkCoreAuthorizationStore<TContext> :
+        OpenIddictEntityFrameworkCoreAuthorizationStore<OpenIddictEntityFrameworkCoreAuthorization,
+                                                        OpenIddictEntityFrameworkCoreApplication,
+                                                        OpenIddictEntityFrameworkCoreToken, TContext, string>
         where TContext : DbContext
     {
-        public OpenIddictAuthorizationStore(
+        public OpenIddictEntityFrameworkCoreAuthorizationStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)
@@ -49,13 +50,14 @@ namespace OpenIddict.EntityFrameworkCore
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictAuthorizationStore<TContext, TKey> : OpenIddictAuthorizationStore<OpenIddictAuthorization<TKey>,
-                                                                                             OpenIddictApplication<TKey>,
-                                                                                             OpenIddictToken<TKey>, TContext, TKey>
+    public class OpenIddictEntityFrameworkCoreAuthorizationStore<TContext, TKey> :
+        OpenIddictEntityFrameworkCoreAuthorizationStore<OpenIddictEntityFrameworkCoreAuthorization<TKey>,
+                                                        OpenIddictEntityFrameworkCoreApplication<TKey>,
+                                                        OpenIddictEntityFrameworkCoreToken<TKey>, TContext, TKey>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictAuthorizationStore(
+        public OpenIddictEntityFrameworkCoreAuthorizationStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)
@@ -72,14 +74,14 @@ namespace OpenIddict.EntityFrameworkCore
     /// <typeparam name="TToken">The type of the Token entity.</typeparam>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictAuthorizationStore<TAuthorization, TApplication, TToken, TContext, TKey> : IOpenIddictAuthorizationStore<TAuthorization>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
+    public class OpenIddictEntityFrameworkCoreAuthorizationStore<TAuthorization, TApplication, TToken, TContext, TKey> : IOpenIddictAuthorizationStore<TAuthorization>
+        where TAuthorization : OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken>
+        where TApplication : OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken>
+        where TToken : OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictAuthorizationStore(
+        public OpenIddictEntityFrameworkCoreAuthorizationStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)

src/OpenIddict.EntityFrameworkCore/Stores/OpenIddictScopeStore.cs → src/OpenIddict.EntityFrameworkCore/Stores/OpenIddictEntityFrameworkCoreScopeStore.cs

@@ -27,10 +27,10 @@ namespace OpenIddict.EntityFrameworkCore
     /// Provides methods allowing to manage the scopes stored in a database.
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
-    public class OpenIddictScopeStore<TContext> : OpenIddictScopeStore<OpenIddictScope, TContext, string>
+    public class OpenIddictEntityFrameworkCoreScopeStore<TContext> : OpenIddictEntityFrameworkCoreScopeStore<OpenIddictEntityFrameworkCoreScope, TContext, string>
         where TContext : DbContext
     {
-        public OpenIddictScopeStore(
+        public OpenIddictEntityFrameworkCoreScopeStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)
@@ -44,11 +44,11 @@ namespace OpenIddict.EntityFrameworkCore
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictScopeStore<TContext, TKey> : OpenIddictScopeStore<OpenIddictScope<TKey>, TContext, TKey>
+    public class OpenIddictEntityFrameworkCoreScopeStore<TContext, TKey> : OpenIddictEntityFrameworkCoreScopeStore<OpenIddictEntityFrameworkCoreScope<TKey>, TContext, TKey>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictScopeStore(
+        public OpenIddictEntityFrameworkCoreScopeStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)
@@ -63,12 +63,12 @@ namespace OpenIddict.EntityFrameworkCore
     /// <typeparam name="TScope">The type of the Scope entity.</typeparam>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictScopeStore<TScope, TContext, TKey> : IOpenIddictScopeStore<TScope>
-        where TScope : OpenIddictScope<TKey>
+    public class OpenIddictEntityFrameworkCoreScopeStore<TScope, TContext, TKey> : IOpenIddictScopeStore<TScope>
+        where TScope : OpenIddictEntityFrameworkCoreScope<TKey>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictScopeStore(
+        public OpenIddictEntityFrameworkCoreScopeStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)

src/OpenIddict.EntityFrameworkCore/Stores/OpenIddictTokenStore.cs → src/OpenIddict.EntityFrameworkCore/Stores/OpenIddictEntityFrameworkCoreTokenStore.cs

@@ -30,12 +30,13 @@ namespace OpenIddict.EntityFrameworkCore
     /// Provides methods allowing to manage the tokens stored in a database.
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
-    public class OpenIddictTokenStore<TContext> : OpenIddictTokenStore<OpenIddictToken,
-                                                                       OpenIddictApplication,
-                                                                       OpenIddictAuthorization, TContext, string>
+    public class OpenIddictEntityFrameworkCoreTokenStore<TContext> :
+        OpenIddictEntityFrameworkCoreTokenStore<OpenIddictEntityFrameworkCoreToken,
+                                                OpenIddictEntityFrameworkCoreApplication,
+                                                OpenIddictEntityFrameworkCoreAuthorization, TContext, string>
         where TContext : DbContext
     {
-        public OpenIddictTokenStore(
+        public OpenIddictEntityFrameworkCoreTokenStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)
@@ -49,13 +50,14 @@ namespace OpenIddict.EntityFrameworkCore
     /// </summary>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictTokenStore<TContext, TKey> : OpenIddictTokenStore<OpenIddictToken<TKey>,
-                                                                             OpenIddictApplication<TKey>,
-                                                                             OpenIddictAuthorization<TKey>, TContext, TKey>
+    public class OpenIddictEntityFrameworkCoreTokenStore<TContext, TKey> :
+        OpenIddictEntityFrameworkCoreTokenStore<OpenIddictEntityFrameworkCoreToken<TKey>,
+                                                OpenIddictEntityFrameworkCoreApplication<TKey>,
+                                                OpenIddictEntityFrameworkCoreAuthorization<TKey>, TContext, TKey>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictTokenStore(
+        public OpenIddictEntityFrameworkCoreTokenStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)
@@ -72,14 +74,14 @@ namespace OpenIddict.EntityFrameworkCore
     /// <typeparam name="TAuthorization">The type of the Authorization entity.</typeparam>
     /// <typeparam name="TContext">The type of the Entity Framework database context.</typeparam>
     /// <typeparam name="TKey">The type of the entity primary keys.</typeparam>
-    public class OpenIddictTokenStore<TToken, TApplication, TAuthorization, TContext, TKey> : IOpenIddictTokenStore<TToken>
-        where TToken : OpenIddictToken<TKey, TApplication, TAuthorization>
-        where TApplication : OpenIddictApplication<TKey, TAuthorization, TToken>
-        where TAuthorization : OpenIddictAuthorization<TKey, TApplication, TToken>
+    public class OpenIddictEntityFrameworkCoreTokenStore<TToken, TApplication, TAuthorization, TContext, TKey> : IOpenIddictTokenStore<TToken>
+        where TToken : OpenIddictEntityFrameworkCoreToken<TKey, TApplication, TAuthorization>
+        where TApplication : OpenIddictEntityFrameworkCoreApplication<TKey, TAuthorization, TToken>
+        where TAuthorization : OpenIddictEntityFrameworkCoreAuthorization<TKey, TApplication, TToken>
         where TContext : DbContext
         where TKey : IEquatable<TKey>
     {
-        public OpenIddictTokenStore(
+        public OpenIddictEntityFrameworkCoreTokenStore(
             [NotNull] IMemoryCache cache,
             [NotNull] TContext context,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options)

src/OpenIddict.MongoDb.Models/OpenIddictApplication.cs → src/OpenIddict.MongoDb.Models/OpenIddictMongoDbApplication.cs

@@ -15,7 +15,7 @@ namespace OpenIddict.MongoDb.Models
     /// Represents an OpenIddict application.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; ClientId = {ClientId,nq} ; Type = {Type,nq}")]
-    public class OpenIddictApplication
+    public class OpenIddictMongoDbApplication
     {
         /// <summary>
         /// Gets or sets the client identifier

src/OpenIddict.MongoDb.Models/OpenIddictAuthorization.cs → src/OpenIddict.MongoDb.Models/OpenIddictMongoDbAuthorization.cs

@@ -15,7 +15,7 @@ namespace OpenIddict.MongoDb.Models
     /// Represents an OpenIddict authorization.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; Subject = {Subject,nq} ; Type = {Type,nq} ; Status = {Status,nq}")]
-    public class OpenIddictAuthorization
+    public class OpenIddictMongoDbAuthorization
     {
         /// <summary>
         /// Gets or sets the identifier of the application

src/OpenIddict.MongoDb.Models/OpenIddictScope.cs → src/OpenIddict.MongoDb.Models/OpenIddictMongoDbScope.cs

@@ -15,7 +15,7 @@ namespace OpenIddict.MongoDb.Models
     /// Represents an OpenIddict scope.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; Name = {Name,nq}")]
-    public class OpenIddictScope
+    public class OpenIddictMongoDbScope
     {
         /// <summary>
         /// Gets or sets the concurrency token.

src/OpenIddict.MongoDb.Models/OpenIddictToken.cs → src/OpenIddict.MongoDb.Models/OpenIddictMongoDbToken.cs

@@ -15,7 +15,7 @@ namespace OpenIddict.MongoDb.Models
     /// Represents an OpenIddict token.
     /// </summary>
     [DebuggerDisplay("Id = {Id.ToString(),nq} ; Subject = {Subject,nq} ; Type = {Type,nq} ; Status = {Status,nq}")]
-    public class OpenIddictToken
+    public class OpenIddictMongoDbToken
     {
         /// <summary>
         /// Gets or sets the identifier of the application associated with the current token.

src/OpenIddict.MongoDb/OpenIddictMongoDbBuilder.cs

@@ -63,7 +63,7 @@ namespace Microsoft.Extensions.DependencyInjection
         /// </summary>
         /// <returns>The <see cref="OpenIddictMongoDbBuilder"/>.</returns>
         public OpenIddictMongoDbBuilder ReplaceDefaultApplicationEntity<TApplication>()
-            where TApplication : OpenIddictApplication
+            where TApplication : OpenIddictMongoDbApplication
         {
             Services.Configure<OpenIddictCoreOptions>(options => options.DefaultApplicationType = typeof(TApplication));
 
@@ -75,7 +75,7 @@ namespace Microsoft.Extensions.DependencyInjection
         /// </summary>
         /// <returns>The <see cref="OpenIddictMongoDbBuilder"/>.</returns>
         public OpenIddictMongoDbBuilder ReplaceDefaultAuthorizationEntity<TAuthorization>()
-            where TAuthorization : OpenIddictAuthorization
+            where TAuthorization : OpenIddictMongoDbAuthorization
         {
             Services.Configure<OpenIddictCoreOptions>(options => options.DefaultAuthorizationType = typeof(TAuthorization));
 
@@ -87,7 +87,7 @@ namespace Microsoft.Extensions.DependencyInjection
         /// </summary>
         /// <returns>The <see cref="OpenIddictMongoDbBuilder"/>.</returns>
         public OpenIddictMongoDbBuilder ReplaceDefaultScopeEntity<TScope>()
-            where TScope : OpenIddictScope
+            where TScope : OpenIddictMongoDbScope
         {
             Services.Configure<OpenIddictCoreOptions>(options => options.DefaultScopeType = typeof(TScope));
 
@@ -99,7 +99,7 @@ namespace Microsoft.Extensions.DependencyInjection
         /// </summary>
         /// <returns>The <see cref="OpenIddictMongoDbBuilder"/>.</returns>
         public OpenIddictMongoDbBuilder ReplaceDefaultTokenEntity<TToken>()
-            where TToken : OpenIddictToken
+            where TToken : OpenIddictMongoDbToken
         {
             Services.Configure<OpenIddictCoreOptions>(options => options.DefaultTokenType = typeof(TToken));
 

src/OpenIddict.MongoDb/OpenIddictMongoDbContext.cs

@@ -98,34 +98,34 @@ namespace OpenIddict.MongoDb
                     {
                         // Note: the cancellation token passed as a parameter is deliberately not used here to ensure
                         // the cancellation of a single store operation doesn't prevent the indexes from being created.
-                        var applications = database.GetCollection<OpenIddictApplication>(options.ApplicationsCollectionName);
+                        var applications = database.GetCollection<OpenIddictMongoDbApplication>(options.ApplicationsCollectionName);
                         await applications.Indexes.CreateManyAsync(new[]
                         {
-                            new CreateIndexModel<OpenIddictApplication>(
-                                Builders<OpenIddictApplication>.IndexKeys.Ascending(application => application.ClientId),
+                            new CreateIndexModel<OpenIddictMongoDbApplication>(
+                                Builders<OpenIddictMongoDbApplication>.IndexKeys.Ascending(application => application.ClientId),
                                 new CreateIndexOptions
                                 {
                                     Unique = true
                                 }),
 
-                            new CreateIndexModel<OpenIddictApplication>(
-                                Builders<OpenIddictApplication>.IndexKeys.Ascending(application => application.PostLogoutRedirectUris),
+                            new CreateIndexModel<OpenIddictMongoDbApplication>(
+                                Builders<OpenIddictMongoDbApplication>.IndexKeys.Ascending(application => application.PostLogoutRedirectUris),
                                 new CreateIndexOptions
                                 {
                                     Background = true
                                 }),
 
-                            new CreateIndexModel<OpenIddictApplication>(
-                                Builders<OpenIddictApplication>.IndexKeys.Ascending(application => application.RedirectUris),
+                            new CreateIndexModel<OpenIddictMongoDbApplication>(
+                                Builders<OpenIddictMongoDbApplication>.IndexKeys.Ascending(application => application.RedirectUris),
                                 new CreateIndexOptions
                                 {
                                     Background = true
                                 })
                         });
 
-                        var authorizations = database.GetCollection<OpenIddictAuthorization>(options.AuthorizationsCollectionName);
-                        await authorizations.Indexes.CreateOneAsync(new CreateIndexModel<OpenIddictAuthorization>(
-                            Builders<OpenIddictAuthorization>.IndexKeys
+                        var authorizations = database.GetCollection<OpenIddictMongoDbAuthorization>(options.AuthorizationsCollectionName);
+                        await authorizations.Indexes.CreateOneAsync(new CreateIndexModel<OpenIddictMongoDbAuthorization>(
+                            Builders<OpenIddictMongoDbAuthorization>.IndexKeys
                                 .Ascending(authorization => authorization.ApplicationId)
                                 .Ascending(authorization => authorization.Scopes)
                                 .Ascending(authorization => authorization.Status)
@@ -136,27 +136,27 @@ namespace OpenIddict.MongoDb
                                 Background = true
                             }));
 
-                        var scopes = database.GetCollection<OpenIddictScope>(options.ScopesCollectionName);
-                        await scopes.Indexes.CreateOneAsync(new CreateIndexModel<OpenIddictScope>(
-                            Builders<OpenIddictScope>.IndexKeys.Ascending(scope => scope.Name),
+                        var scopes = database.GetCollection<OpenIddictMongoDbScope>(options.ScopesCollectionName);
+                        await scopes.Indexes.CreateOneAsync(new CreateIndexModel<OpenIddictMongoDbScope>(
+                            Builders<OpenIddictMongoDbScope>.IndexKeys.Ascending(scope => scope.Name),
                             new CreateIndexOptions
                             {
                                 Unique = true
                             }));
 
-                        var tokens = database.GetCollection<OpenIddictToken>(options.TokensCollectionName);
+                        var tokens = database.GetCollection<OpenIddictMongoDbToken>(options.TokensCollectionName);
                         await tokens.Indexes.CreateManyAsync(new[]
                         {
-                            new CreateIndexModel<OpenIddictToken>(
-                                Builders<OpenIddictToken>.IndexKeys.Ascending(token => token.ReferenceId),
-                                new CreateIndexOptions<OpenIddictToken>
+                            new CreateIndexModel<OpenIddictMongoDbToken>(
+                                Builders<OpenIddictMongoDbToken>.IndexKeys.Ascending(token => token.ReferenceId),
+                                new CreateIndexOptions<OpenIddictMongoDbToken>
                                 {
-                                    PartialFilterExpression = Builders<OpenIddictToken>.Filter.Exists(token => token.ReferenceId),
+                                    PartialFilterExpression = Builders<OpenIddictMongoDbToken>.Filter.Exists(token => token.ReferenceId),
                                     Unique = true
                                 }),
 
-                            new CreateIndexModel<OpenIddictToken>(
-                                Builders<OpenIddictToken>.IndexKeys
+                            new CreateIndexModel<OpenIddictMongoDbToken>(
+                                Builders<OpenIddictMongoDbToken>.IndexKeys
                                     .Ascending(token => token.ApplicationId)
                                     .Ascending(token => token.Status)
                                     .Ascending(token => token.Subject)

src/OpenIddict.MongoDb/OpenIddictMongoDbExtensions.cs

@@ -35,22 +35,22 @@ namespace Microsoft.Extensions.DependencyInjection
             // query filtering applied by the default OpenIddict managers can be safely disabled.
             builder.DisableAdditionalFiltering();
 
-            builder.SetDefaultApplicationEntity<OpenIddictApplication>()
-                   .SetDefaultAuthorizationEntity<OpenIddictAuthorization>()
-                   .SetDefaultScopeEntity<OpenIddictScope>()
-                   .SetDefaultTokenEntity<OpenIddictToken>();
+            builder.SetDefaultApplicationEntity<OpenIddictMongoDbApplication>()
+                   .SetDefaultAuthorizationEntity<OpenIddictMongoDbAuthorization>()
+                   .SetDefaultScopeEntity<OpenIddictMongoDbScope>()
+                   .SetDefaultTokenEntity<OpenIddictMongoDbToken>();
 
             // Note: the Mongo stores/resolvers don't depend on scoped/transient services and thus
             // can be safely registered as singleton services and shared/reused across requests.
-            builder.ReplaceApplicationStoreResolver<OpenIddictApplicationStoreResolver>(ServiceLifetime.Singleton)
-                   .ReplaceAuthorizationStoreResolver<OpenIddictAuthorizationStoreResolver>(ServiceLifetime.Singleton)
-                   .ReplaceScopeStoreResolver<OpenIddictScopeStoreResolver>(ServiceLifetime.Singleton)
-                   .ReplaceTokenStoreResolver<OpenIddictTokenStoreResolver>(ServiceLifetime.Singleton);
+            builder.ReplaceApplicationStoreResolver<OpenIddictMongoDbApplicationStoreResolver>(ServiceLifetime.Singleton)
+                   .ReplaceAuthorizationStoreResolver<OpenIddictMongoDbAuthorizationStoreResolver>(ServiceLifetime.Singleton)
+                   .ReplaceScopeStoreResolver<OpenIddictMongoDbScopeStoreResolver>(ServiceLifetime.Singleton)
+                   .ReplaceTokenStoreResolver<OpenIddictMongoDbTokenStoreResolver>(ServiceLifetime.Singleton);
 
-            builder.Services.TryAddSingleton(typeof(OpenIddictApplicationStore<>));
-            builder.Services.TryAddSingleton(typeof(OpenIddictAuthorizationStore<>));
-            builder.Services.TryAddSingleton(typeof(OpenIddictScopeStore<>));
-            builder.Services.TryAddSingleton(typeof(OpenIddictTokenStore<>));
+            builder.Services.TryAddSingleton(typeof(OpenIddictMongoDbApplicationStore<>));
+            builder.Services.TryAddSingleton(typeof(OpenIddictMongoDbAuthorizationStore<>));
+            builder.Services.TryAddSingleton(typeof(OpenIddictMongoDbScopeStore<>));
+            builder.Services.TryAddSingleton(typeof(OpenIddictMongoDbTokenStore<>));
 
             builder.Services.TryAddSingleton<IOpenIddictMongoDbContext, OpenIddictMongoDbContext>();
 

src/OpenIddict.MongoDb/Resolvers/OpenIddictApplicationStoreResolver.cs → src/OpenIddict.MongoDb/Resolvers/OpenIddictMongoDbApplicationStoreResolver.cs

@@ -17,12 +17,12 @@ namespace OpenIddict.MongoDb
     /// <summary>
     /// Exposes a method allowing to resolve an application store.
     /// </summary>
-    public class OpenIddictApplicationStoreResolver : IOpenIddictApplicationStoreResolver
+    public class OpenIddictMongoDbApplicationStoreResolver : IOpenIddictApplicationStoreResolver
     {
         private readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
         private readonly IServiceProvider _provider;
 
-        public OpenIddictApplicationStoreResolver([NotNull] IServiceProvider provider)
+        public OpenIddictMongoDbApplicationStoreResolver([NotNull] IServiceProvider provider)
             => _provider = provider;
 
         /// <summary>
@@ -41,17 +41,17 @@ namespace OpenIddict.MongoDb
 
             var type = _cache.GetOrAdd(typeof(TApplication), key =>
             {
-                if (!typeof(OpenIddictApplication).IsAssignableFrom(key))
+                if (!typeof(OpenIddictMongoDbApplication).IsAssignableFrom(key))
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified application type is not compatible with the MongoDB stores.")
-                        .Append("When enabling the MongoDB stores, make sure you use the built-in 'OpenIddictApplication' ")
-                        .Append("entity (from the 'OpenIddict.MongoDb.Models' package) or a custom entity ")
-                        .Append("that inherits from the 'OpenIddictApplication' entity.")
+                        .Append("When enabling the MongoDB stores, make sure you use the built-in ")
+                        .Append("'OpenIddictMongoDbApplication' entity or a custom entity that inherits ")
+                        .Append("from the 'OpenIddictMongoDbApplication' entity.")
                         .ToString());
                 }
 
-                return typeof(OpenIddictApplicationStore<>).MakeGenericType(key);
+                return typeof(OpenIddictMongoDbApplicationStore<>).MakeGenericType(key);
             });
 
             return (IOpenIddictApplicationStore<TApplication>) _provider.GetRequiredService(type);

src/OpenIddict.MongoDb/Resolvers/OpenIddictAuthorizationStoreResolver.cs → src/OpenIddict.MongoDb/Resolvers/OpenIddictMongoDbAuthorizationStoreResolver.cs

@@ -17,12 +17,12 @@ namespace OpenIddict.MongoDb
     /// <summary>
     /// Exposes a method allowing to resolve an authorization store.
     /// </summary>
-    public class OpenIddictAuthorizationStoreResolver : IOpenIddictAuthorizationStoreResolver
+    public class OpenIddictMongoDbAuthorizationStoreResolver : IOpenIddictAuthorizationStoreResolver
     {
         private readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
         private readonly IServiceProvider _provider;
 
-        public OpenIddictAuthorizationStoreResolver([NotNull] IServiceProvider provider)
+        public OpenIddictMongoDbAuthorizationStoreResolver([NotNull] IServiceProvider provider)
             => _provider = provider;
 
         /// <summary>
@@ -41,17 +41,17 @@ namespace OpenIddict.MongoDb
 
             var type = _cache.GetOrAdd(typeof(TAuthorization), key =>
             {
-                if (!typeof(OpenIddictAuthorization).IsAssignableFrom(key))
+                if (!typeof(OpenIddictMongoDbAuthorization).IsAssignableFrom(key))
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified authorization type is not compatible with the MongoDB stores.")
-                        .Append("When enabling the MongoDB stores, make sure you use the built-in 'OpenIddictAuthorization' ")
-                        .Append("entity (from the 'OpenIddict.MongoDb.Models' package) or a custom entity ")
-                        .Append("that inherits from the 'OpenIddictAuthorization' entity.")
+                        .Append("When enabling the MongoDB stores, make sure you use the built-in ")
+                        .Append("'OpenIddictMongoDbAuthorization' entity or a custom entity that inherits ")
+                        .Append("from the 'OpenIddictMongoDbAuthorization' entity.")
                         .ToString());
                 }
 
-                return typeof(OpenIddictAuthorizationStore<>).MakeGenericType(key);
+                return typeof(OpenIddictMongoDbAuthorizationStore<>).MakeGenericType(key);
             });
 
             return (IOpenIddictAuthorizationStore<TAuthorization>) _provider.GetRequiredService(type);

src/OpenIddict.MongoDb/Resolvers/OpenIddictScopeStoreResolver.cs → src/OpenIddict.MongoDb/Resolvers/OpenIddictMongoDbScopeStoreResolver.cs

@@ -17,12 +17,12 @@ namespace OpenIddict.MongoDb
     /// <summary>
     /// Exposes a method allowing to resolve a scope store.
     /// </summary>
-    public class OpenIddictScopeStoreResolver : IOpenIddictScopeStoreResolver
+    public class OpenIddictMongoDbScopeStoreResolver : IOpenIddictScopeStoreResolver
     {
         private readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
         private readonly IServiceProvider _provider;
 
-        public OpenIddictScopeStoreResolver([NotNull] IServiceProvider provider)
+        public OpenIddictMongoDbScopeStoreResolver([NotNull] IServiceProvider provider)
             => _provider = provider;
 
         /// <summary>
@@ -41,17 +41,17 @@ namespace OpenIddict.MongoDb
 
             var type = _cache.GetOrAdd(typeof(TScope), key =>
             {
-                if (!typeof(OpenIddictScope).IsAssignableFrom(key))
+                if (!typeof(OpenIddictMongoDbScope).IsAssignableFrom(key))
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified scope type is not compatible with the MongoDB stores.")
-                        .Append("When enabling the MongoDB stores, make sure you use the built-in 'OpenIddictScope' ")
-                        .Append("entity (from the 'OpenIddict.MongoDb.Models' package) or a custom entity ")
-                        .Append("that inherits from the 'OpenIddictScope' entity.")
+                        .Append("When enabling the MongoDB stores, make sure you use the built-in ")
+                        .Append("'OpenIddictMongoDbScope' entity or a custom entity that inherits ")
+                        .Append("from the 'OpenIddictMongoDbScope' entity.")
                         .ToString());
                 }
 
-                return typeof(OpenIddictScopeStore<>).MakeGenericType(key);
+                return typeof(OpenIddictMongoDbScopeStore<>).MakeGenericType(key);
             });
 
             return (IOpenIddictScopeStore<TScope>) _provider.GetRequiredService(type);

src/OpenIddict.MongoDb/Resolvers/OpenIddictTokenStoreResolver.cs → src/OpenIddict.MongoDb/Resolvers/OpenIddictMongoDbTokenStoreResolver.cs

@@ -17,12 +17,12 @@ namespace OpenIddict.MongoDb
     /// <summary>
     /// Exposes a method allowing to resolve a token store.
     /// </summary>
-    public class OpenIddictTokenStoreResolver : IOpenIddictTokenStoreResolver
+    public class OpenIddictMongoDbTokenStoreResolver : IOpenIddictTokenStoreResolver
     {
         private readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
         private readonly IServiceProvider _provider;
 
-        public OpenIddictTokenStoreResolver([NotNull] IServiceProvider provider)
+        public OpenIddictMongoDbTokenStoreResolver([NotNull] IServiceProvider provider)
             => _provider = provider;
 
         /// <summary>
@@ -41,17 +41,17 @@ namespace OpenIddict.MongoDb
 
             var type = _cache.GetOrAdd(typeof(TToken), key =>
             {
-                if (!typeof(OpenIddictToken).IsAssignableFrom(key))
+                if (!typeof(OpenIddictMongoDbToken).IsAssignableFrom(key))
                 {
                     throw new InvalidOperationException(new StringBuilder()
                         .AppendLine("The specified token type is not compatible with the MongoDB stores.")
-                        .Append("When enabling the MongoDB stores, make sure you use the built-in 'OpenIddictToken' ")
-                        .Append("entity (from the 'OpenIddict.MongoDb.Models' package) or a custom entity ")
-                        .Append("that inherits from the 'OpenIddictToken' entity.")
+                        .Append("When enabling the MongoDB stores, make sure you use the built-in ")
+                        .Append("'OpenIddictMongoDbToken' entity or a custom entity that inherits ")
+                        .Append("from the 'OpenIddictMongoDbToken' entity.")
                         .ToString());
                 }
 
-                return typeof(OpenIddictTokenStore<>).MakeGenericType(key);
+                return typeof(OpenIddictMongoDbTokenStore<>).MakeGenericType(key);
             });
 
             return (IOpenIddictTokenStore<TToken>) _provider.GetRequiredService(type);

src/OpenIddict.MongoDb/Stores/OpenIddictApplicationStore.cs → src/OpenIddict.MongoDb/Stores/OpenIddictMongoDbApplicationStore.cs

@@ -28,10 +28,10 @@ namespace OpenIddict.MongoDb
     /// Provides methods allowing to manage the applications stored in a database.
     /// </summary>
     /// <typeparam name="TApplication">The type of the Application entity.</typeparam>
-    public class OpenIddictApplicationStore<TApplication> : IOpenIddictApplicationStore<TApplication>
-        where TApplication : OpenIddictApplication
+    public class OpenIddictMongoDbApplicationStore<TApplication> : IOpenIddictApplicationStore<TApplication>
+        where TApplication : OpenIddictMongoDbApplication
     {
-        public OpenIddictApplicationStore(
+        public OpenIddictMongoDbApplicationStore(
             [NotNull] IOpenIddictMongoDbContext context,
             [NotNull] IOptionsMonitor<OpenIddictMongoDbOptions> options)
         {
@@ -135,11 +135,11 @@ namespace OpenIddict.MongoDb
             }
 
             // Delete the authorizations associated with the application.
-            await database.GetCollection<OpenIddictAuthorization>(Options.CurrentValue.AuthorizationsCollectionName)
+            await database.GetCollection<OpenIddictMongoDbAuthorization>(Options.CurrentValue.AuthorizationsCollectionName)
                 .DeleteManyAsync(authorization => authorization.ApplicationId == application.Id, cancellationToken);
 
             // Delete the tokens associated with the application.
-            await database.GetCollection<OpenIddictToken>(Options.CurrentValue.TokensCollectionName)
+            await database.GetCollection<OpenIddictMongoDbToken>(Options.CurrentValue.TokensCollectionName)
                 .DeleteManyAsync(token => token.ApplicationId == application.Id, cancellationToken);
         }
 

src/OpenIddict.MongoDb/Stores/OpenIddictAuthorizationStore.cs → src/OpenIddict.MongoDb/Stores/OpenIddictMongoDbAuthorizationStore.cs

@@ -28,10 +28,10 @@ namespace OpenIddict.MongoDb
     /// Provides methods allowing to manage the authorizations stored in a database.
     /// </summary>
     /// <typeparam name="TAuthorization">The type of the Authorization entity.</typeparam>
-    public class OpenIddictAuthorizationStore<TAuthorization> : IOpenIddictAuthorizationStore<TAuthorization>
-        where TAuthorization : OpenIddictAuthorization
+    public class OpenIddictMongoDbAuthorizationStore<TAuthorization> : IOpenIddictAuthorizationStore<TAuthorization>
+        where TAuthorization : OpenIddictMongoDbAuthorization
     {
-        public OpenIddictAuthorizationStore(
+        public OpenIddictMongoDbAuthorizationStore(
             [NotNull] IOpenIddictMongoDbContext context,
             [NotNull] IOptionsMonitor<OpenIddictMongoDbOptions> options)
         {
@@ -135,7 +135,7 @@ namespace OpenIddict.MongoDb
             }
 
             // Delete the tokens associated with the authorization.
-            await database.GetCollection<OpenIddictToken>(Options.CurrentValue.TokensCollectionName)
+            await database.GetCollection<OpenIddictMongoDbToken>(Options.CurrentValue.TokensCollectionName)
                 .DeleteManyAsync(token => token.AuthorizationId == authorization.Id, cancellationToken);
         }
 
@@ -685,7 +685,7 @@ namespace OpenIddict.MongoDb
 
             var identifiers =
                 await (from authorization in collection.AsQueryable()
-                       join token in database.GetCollection<OpenIddictToken>(Options.CurrentValue.TokensCollectionName).AsQueryable()
+                       join token in database.GetCollection<OpenIddictMongoDbToken>(Options.CurrentValue.TokensCollectionName).AsQueryable()
                                   on authorization.Id equals token.AuthorizationId into tokens
                        where authorization.Status != OpenIddictConstants.Statuses.Valid ||
                             (authorization.Type == OpenIddictConstants.AuthorizationTypes.AdHoc &&
@@ -700,7 +700,7 @@ namespace OpenIddict.MongoDb
                 await collection.DeleteManyAsync(authorization => buffer.Contains(authorization.Id));
 
                 // Delete the tokens associated with the pruned authorizations.
-                await database.GetCollection<OpenIddictToken>(Options.CurrentValue.TokensCollectionName)
+                await database.GetCollection<OpenIddictMongoDbToken>(Options.CurrentValue.TokensCollectionName)
                     .DeleteManyAsync(token => buffer.Contains(token.AuthorizationId), cancellationToken);
             }
 

src/OpenIddict.MongoDb/Stores/OpenIddictScopeStore.cs → src/OpenIddict.MongoDb/Stores/OpenIddictMongoDbScopeStore.cs

@@ -28,10 +28,10 @@ namespace OpenIddict.MongoDb
     /// Provides methods allowing to manage the scopes stored in a database.
     /// </summary>
     /// <typeparam name="TScope">The type of the Scope entity.</typeparam>
-    public class OpenIddictScopeStore<TScope> : IOpenIddictScopeStore<TScope>
-        where TScope : OpenIddictScope
+    public class OpenIddictMongoDbScopeStore<TScope> : IOpenIddictScopeStore<TScope>
+        where TScope : OpenIddictMongoDbScope
     {
-        public OpenIddictScopeStore(
+        public OpenIddictMongoDbScopeStore(
             [NotNull] IOpenIddictMongoDbContext context,
             [NotNull] IOptionsMonitor<OpenIddictMongoDbOptions> options)
         {

src/OpenIddict.MongoDb/Stores/OpenIddictTokenStore.cs → src/OpenIddict.MongoDb/Stores/OpenIddictMongoDbTokenStore.cs

@@ -28,10 +28,10 @@ namespace OpenIddict.MongoDb
     /// Provides methods allowing to manage the tokens stored in a database.
     /// </summary>
     /// <typeparam name="TToken">The type of the Token entity.</typeparam>
-    public class OpenIddictTokenStore<TToken> : IOpenIddictTokenStore<TToken>
-        where TToken : OpenIddictToken
+    public class OpenIddictMongoDbTokenStore<TToken> : IOpenIddictTokenStore<TToken>
+        where TToken : OpenIddictMongoDbToken
     {
-        public OpenIddictTokenStore(
+        public OpenIddictMongoDbTokenStore(
             [NotNull] IOpenIddictMongoDbContext context,
             [NotNull] IOptionsMonitor<OpenIddictMongoDbOptions> options)
         {

test/OpenIddict.EntityFramework.Tests/OpenIddictEntityFrameworkBuilderTests.cs

@@ -125,10 +125,10 @@ namespace OpenIddict.EntityFramework.Tests
             return services;
         }
 
-        public class CustomApplication : OpenIddictApplication<long, CustomAuthorization, CustomToken> { }
-        public class CustomAuthorization : OpenIddictAuthorization<long, CustomApplication, CustomToken> { }
-        public class CustomScope : OpenIddictScope<long> { }
-        public class CustomToken : OpenIddictToken<long, CustomApplication, CustomAuthorization> { }
+        public class CustomApplication : OpenIddictEntityFrameworkApplication<long, CustomAuthorization, CustomToken> { }
+        public class CustomAuthorization : OpenIddictEntityFrameworkAuthorization<long, CustomApplication, CustomToken> { }
+        public class CustomScope : OpenIddictEntityFrameworkScope<long> { }
+        public class CustomToken : OpenIddictEntityFrameworkToken<long, CustomApplication, CustomAuthorization> { }
 
         public class CustomDbContext : DbContext
         {

test/OpenIddict.EntityFramework.Tests/OpenIddictEntityFrameworkExtensionsTests.cs

@@ -55,17 +55,17 @@ namespace OpenIddict.EntityFramework.Tests
             var provider = services.BuildServiceProvider();
             var options = provider.GetRequiredService<IOptionsMonitor<OpenIddictCoreOptions>>().CurrentValue;
 
-            Assert.Equal(typeof(OpenIddictApplication), options.DefaultApplicationType);
-            Assert.Equal(typeof(OpenIddictAuthorization), options.DefaultAuthorizationType);
-            Assert.Equal(typeof(OpenIddictScope), options.DefaultScopeType);
-            Assert.Equal(typeof(OpenIddictToken), options.DefaultTokenType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkApplication), options.DefaultApplicationType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkAuthorization), options.DefaultAuthorizationType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkScope), options.DefaultScopeType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkToken), options.DefaultTokenType);
         }
 
         [Theory]
-        [InlineData(typeof(IOpenIddictApplicationStoreResolver), typeof(OpenIddictApplicationStoreResolver))]
-        [InlineData(typeof(IOpenIddictAuthorizationStoreResolver), typeof(OpenIddictAuthorizationStoreResolver))]
-        [InlineData(typeof(IOpenIddictScopeStoreResolver), typeof(OpenIddictScopeStoreResolver))]
-        [InlineData(typeof(IOpenIddictTokenStoreResolver), typeof(OpenIddictTokenStoreResolver))]
+        [InlineData(typeof(IOpenIddictApplicationStoreResolver), typeof(OpenIddictEntityFrameworkApplicationStoreResolver))]
+        [InlineData(typeof(IOpenIddictAuthorizationStoreResolver), typeof(OpenIddictEntityFrameworkAuthorizationStoreResolver))]
+        [InlineData(typeof(IOpenIddictScopeStoreResolver), typeof(OpenIddictEntityFrameworkScopeStoreResolver))]
+        [InlineData(typeof(IOpenIddictTokenStoreResolver), typeof(OpenIddictEntityFrameworkTokenStoreResolver))]
         public void UseEntityFramework_RegistersEntityFrameworkStoreResolvers(Type serviceType, Type implementationType)
         {
             // Arrange
@@ -81,10 +81,10 @@ namespace OpenIddict.EntityFramework.Tests
         }
 
         [Theory]
-        [InlineData(typeof(OpenIddictApplicationStoreResolver.TypeResolutionCache))]
-        [InlineData(typeof(OpenIddictAuthorizationStoreResolver.TypeResolutionCache))]
-        [InlineData(typeof(OpenIddictScopeStoreResolver.TypeResolutionCache))]
-        [InlineData(typeof(OpenIddictTokenStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictEntityFrameworkApplicationStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictEntityFrameworkAuthorizationStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictEntityFrameworkScopeStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictEntityFrameworkTokenStoreResolver.TypeResolutionCache))]
         public void UseEntityFramework_RegistersEntityFrameworkStoreResolverCaches(Type type)
         {
             // Arrange
@@ -100,10 +100,10 @@ namespace OpenIddict.EntityFramework.Tests
         }
 
         [Theory]
-        [InlineData(typeof(OpenIddictApplicationStore<,,,,>))]
-        [InlineData(typeof(OpenIddictAuthorizationStore<,,,,>))]
-        [InlineData(typeof(OpenIddictScopeStore<,,>))]
-        [InlineData(typeof(OpenIddictTokenStore<,,,,>))]
+        [InlineData(typeof(OpenIddictEntityFrameworkApplicationStore<,,,,>))]
+        [InlineData(typeof(OpenIddictEntityFrameworkAuthorizationStore<,,,,>))]
+        [InlineData(typeof(OpenIddictEntityFrameworkScopeStore<,,>))]
+        [InlineData(typeof(OpenIddictEntityFrameworkTokenStore<,,,,>))]
         public void UseEntityFramework_RegistersEntityFrameworkStore(Type type)
         {
             // Arrange

test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs → test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictEntityFrameworkApplicationStoreResolverTests.cs

@@ -14,11 +14,11 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFramework.Models;
 using Xunit;
-using static OpenIddict.EntityFramework.OpenIddictApplicationStoreResolver;
+using static OpenIddict.EntityFramework.OpenIddictEntityFrameworkApplicationStoreResolver;
 
 namespace OpenIddict.EntityFramework.Tests
 {
-    public class OpenIddictApplicationStoreResolverTests
+    public class OpenIddictEntityFrameworkApplicationStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -29,7 +29,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomApplication>());
@@ -43,7 +43,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomApplication>());
@@ -51,8 +51,8 @@ namespace OpenIddict.EntityFramework.Tests
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified application type is not compatible with the Entity Framework 6.x stores.")
                 .Append("When enabling the Entity Framework 6.x stores, make sure you use the built-in ")
-                .Append("'OpenIddictApplication' entity (from the 'OpenIddict.EntityFramework.Models' package) ")
-                .Append("or a custom entity that inherits from the generic 'OpenIddictApplication' entity.")
+                .Append("'OpenIddictEntityFrameworkApplication' entity or a custom entity that inherits ")
+                .Append("from the generic 'OpenIddictEntityFrameworkApplication' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -69,10 +69,10 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
-            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictApplication>());
+            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictEntityFrameworkApplication>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("No Entity Framework 6.x context was specified in the OpenIddict options.")
@@ -96,23 +96,23 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyApplication>());
         }
 
-        private static OpenIddictApplicationStore<MyApplication, MyAuthorization, MyToken, DbContext, long> CreateStore() 
-            => new Mock<OpenIddictApplicationStore<MyApplication, MyAuthorization, MyToken, DbContext, long>>(
+        private static OpenIddictEntityFrameworkApplicationStore<MyApplication, MyAuthorization, MyToken, DbContext, long> CreateStore() 
+            => new Mock<OpenIddictEntityFrameworkApplicationStore<MyApplication, MyAuthorization, MyToken, DbContext, long>>(
                 Mock.Of<IMemoryCache>(),
                 Mock.Of<DbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>()).Object;
 
         public class CustomApplication { }
 
-        public class MyApplication : OpenIddictApplication<long, MyAuthorization, MyToken> { }
-        public class MyAuthorization : OpenIddictAuthorization<long, MyApplication, MyToken> { }
-        public class MyScope : OpenIddictScope<long> { }
-        public class MyToken : OpenIddictToken<long, MyApplication, MyAuthorization> { }
+        public class MyApplication : OpenIddictEntityFrameworkApplication<long, MyAuthorization, MyToken> { }
+        public class MyAuthorization : OpenIddictEntityFrameworkAuthorization<long, MyApplication, MyToken> { }
+        public class MyScope : OpenIddictEntityFrameworkScope<long> { }
+        public class MyToken : OpenIddictEntityFrameworkToken<long, MyApplication, MyAuthorization> { }
     }
 }

test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs → test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictEntityFrameworkAuthorizationStoreResolverTests.cs

@@ -14,11 +14,11 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFramework.Models;
 using Xunit;
-using static OpenIddict.EntityFramework.OpenIddictAuthorizationStoreResolver;
+using static OpenIddict.EntityFramework.OpenIddictEntityFrameworkAuthorizationStoreResolver;
 
 namespace OpenIddict.EntityFramework.Tests
 {
-    public class OpenIddictAuthorizationStoreResolverTests
+    public class OpenIddictEntityFrameworkAuthorizationStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -29,7 +29,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomAuthorization>());
@@ -43,7 +43,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomAuthorization>());
@@ -51,8 +51,8 @@ namespace OpenIddict.EntityFramework.Tests
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified authorization type is not compatible with the Entity Framework 6.x stores.")
                 .Append("When enabling the Entity Framework 6.x stores, make sure you use the built-in ")
-                .Append("'OpenIddictAuthorization' entity (from the 'OpenIddict.EntityFramework.Models' package) ")
-                .Append("or a custom entity that inherits from the generic 'OpenIddictAuthorization' entity.")
+                .Append("'OpenIddictEntityFrameworkAuthorization' entity or a custom entity that inherits ")
+                .Append("from the generic 'OpenIddictEntityFrameworkAuthorization' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -69,10 +69,10 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
-            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictAuthorization>());
+            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictEntityFrameworkAuthorization>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("No Entity Framework 6.x context was specified in the OpenIddict options.")
@@ -96,23 +96,23 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyAuthorization>());
         }
 
-        private static OpenIddictAuthorizationStore<MyAuthorization, MyApplication, MyToken, DbContext, long> CreateStore()
-            => new Mock<OpenIddictAuthorizationStore<MyAuthorization, MyApplication, MyToken, DbContext, long>>(
+        private static OpenIddictEntityFrameworkAuthorizationStore<MyAuthorization, MyApplication, MyToken, DbContext, long> CreateStore()
+            => new Mock<OpenIddictEntityFrameworkAuthorizationStore<MyAuthorization, MyApplication, MyToken, DbContext, long>>(
                 Mock.Of<IMemoryCache>(),
                 Mock.Of<DbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>()).Object;
 
         public class CustomAuthorization { }
 
-        public class MyApplication : OpenIddictApplication<long, MyAuthorization, MyToken> { }
-        public class MyAuthorization : OpenIddictAuthorization<long, MyApplication, MyToken> { }
-        public class MyScope : OpenIddictScope<long> { }
-        public class MyToken : OpenIddictToken<long, MyApplication, MyAuthorization> { }
+        public class MyApplication : OpenIddictEntityFrameworkApplication<long, MyAuthorization, MyToken> { }
+        public class MyAuthorization : OpenIddictEntityFrameworkAuthorization<long, MyApplication, MyToken> { }
+        public class MyScope : OpenIddictEntityFrameworkScope<long> { }
+        public class MyToken : OpenIddictEntityFrameworkToken<long, MyApplication, MyAuthorization> { }
     }
 }

test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs → test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictEntityFrameworkScopeStoreResolverTests.cs

@@ -14,11 +14,11 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFramework.Models;
 using Xunit;
-using static OpenIddict.EntityFramework.OpenIddictScopeStoreResolver;
+using static OpenIddict.EntityFramework.OpenIddictEntityFrameworkScopeStoreResolver;
 
 namespace OpenIddict.EntityFramework.Tests
 {
-    public class OpenIddictScopeStoreResolverTests
+    public class OpenIddictEntityFrameworkScopeStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -29,7 +29,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomScope>());
@@ -43,7 +43,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomScope>());
@@ -51,8 +51,8 @@ namespace OpenIddict.EntityFramework.Tests
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified scope type is not compatible with the Entity Framework 6.x stores.")
                 .Append("When enabling the Entity Framework 6.x stores, make sure you use the built-in ")
-                .Append("'OpenIddictScope' entity (from the 'OpenIddict.EntityFramework.Models' package) ")
-                .Append("or a custom entity that inherits from the generic 'OpenIddictScope' entity.")
+                .Append("'OpenIddictEntityFrameworkScope' entity or a custom entity that inherits ")
+                .Append("from the generic 'OpenIddictEntityFrameworkScope' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -69,10 +69,10 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
-            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictScope>());
+            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictEntityFrameworkScope>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("No Entity Framework 6.x context was specified in the OpenIddict options.")
@@ -96,23 +96,23 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyScope>());
         }
 
-        private static OpenIddictScopeStore<MyScope, DbContext, long> CreateStore()
-            => new Mock<OpenIddictScopeStore<MyScope, DbContext, long>>(
+        private static OpenIddictEntityFrameworkScopeStore<MyScope, DbContext, long> CreateStore()
+            => new Mock<OpenIddictEntityFrameworkScopeStore<MyScope, DbContext, long>>(
                 Mock.Of<IMemoryCache>(),
                 Mock.Of<DbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>()).Object;
 
         public class CustomScope { }
 
-        public class MyApplication : OpenIddictApplication<long, MyAuthorization, MyToken> { }
-        public class MyAuthorization : OpenIddictAuthorization<long, MyApplication, MyToken> { }
-        public class MyScope : OpenIddictScope<long> { }
-        public class MyToken : OpenIddictToken<long, MyApplication, MyAuthorization> { }
+        public class MyApplication : OpenIddictEntityFrameworkApplication<long, MyAuthorization, MyToken> { }
+        public class MyAuthorization : OpenIddictEntityFrameworkAuthorization<long, MyApplication, MyToken> { }
+        public class MyScope : OpenIddictEntityFrameworkScope<long> { }
+        public class MyToken : OpenIddictEntityFrameworkToken<long, MyApplication, MyAuthorization> { }
     }
 }

test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs → test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictEntityFrameworkTokenStoreResolverTests.cs

@@ -14,11 +14,11 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFramework.Models;
 using Xunit;
-using static OpenIddict.EntityFramework.OpenIddictTokenStoreResolver;
+using static OpenIddict.EntityFramework.OpenIddictEntityFrameworkTokenStoreResolver;
 
 namespace OpenIddict.EntityFramework.Tests
 {
-    public class OpenIddictTokenStoreResolverTests
+    public class OpenIddictEntityFrameworkTokenStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -29,7 +29,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomToken>());
@@ -43,7 +43,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomToken>());
@@ -51,8 +51,8 @@ namespace OpenIddict.EntityFramework.Tests
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified token type is not compatible with the Entity Framework 6.x stores.")
                 .Append("When enabling the Entity Framework 6.x stores, make sure you use the built-in ")
-                .Append("'OpenIddictToken' entity (from the 'OpenIddict.EntityFramework.Models' package) ")
-                .Append("or a custom entity that inherits from the generic 'OpenIddictToken' entity.")
+                .Append("'OpenIddictEntityFrameworkToken' entity or a custom entity that inherits ")
+                .Append("from the generic 'OpenIddictEntityFrameworkToken' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -69,10 +69,10 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
-            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictToken>());
+            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictEntityFrameworkToken>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("No Entity Framework 6.x context was specified in the OpenIddict options.")
@@ -96,23 +96,23 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyToken>());
         }
 
-        private static OpenIddictTokenStore<MyToken, MyApplication, MyAuthorization, DbContext, long> CreateStore()
-            => new Mock<OpenIddictTokenStore<MyToken, MyApplication, MyAuthorization, DbContext, long>>(
+        private static OpenIddictEntityFrameworkTokenStore<MyToken, MyApplication, MyAuthorization, DbContext, long> CreateStore()
+            => new Mock<OpenIddictEntityFrameworkTokenStore<MyToken, MyApplication, MyAuthorization, DbContext, long>>(
                 Mock.Of<IMemoryCache>(),
                 Mock.Of<DbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>()).Object;
 
         public class CustomToken { }
 
-        public class MyApplication : OpenIddictApplication<long, MyAuthorization, MyToken> { }
-        public class MyAuthorization : OpenIddictAuthorization<long, MyApplication, MyToken> { }
-        public class MyScope : OpenIddictScope<long> { }
-        public class MyToken : OpenIddictToken<long, MyApplication, MyAuthorization> { }
+        public class MyApplication : OpenIddictEntityFrameworkApplication<long, MyAuthorization, MyToken> { }
+        public class MyAuthorization : OpenIddictEntityFrameworkAuthorization<long, MyApplication, MyToken> { }
+        public class MyScope : OpenIddictEntityFrameworkScope<long> { }
+        public class MyToken : OpenIddictEntityFrameworkToken<long, MyApplication, MyAuthorization> { }
     }
 }

test/OpenIddict.EntityFrameworkCore.Tests/OpenIddictEntityFrameworkCoreBuilderTests.cs

@@ -62,10 +62,10 @@ namespace OpenIddict.EntityFrameworkCore.Tests
             var provider = services.BuildServiceProvider();
             var options = provider.GetRequiredService<IOptionsMonitor<OpenIddictCoreOptions>>().CurrentValue;
 
-            Assert.Equal(typeof(OpenIddictApplication<long>), options.DefaultApplicationType);
-            Assert.Equal(typeof(OpenIddictAuthorization<long>), options.DefaultAuthorizationType);
-            Assert.Equal(typeof(OpenIddictScope<long>), options.DefaultScopeType);
-            Assert.Equal(typeof(OpenIddictToken<long>), options.DefaultTokenType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkCoreApplication<long>), options.DefaultApplicationType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkCoreAuthorization<long>), options.DefaultAuthorizationType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkCoreScope<long>), options.DefaultScopeType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkCoreToken<long>), options.DefaultTokenType);
         }
 
         [Fact]
@@ -129,10 +129,10 @@ namespace OpenIddict.EntityFrameworkCore.Tests
             return services;
         }
 
-        public class CustomApplication : OpenIddictApplication<long, CustomAuthorization, CustomToken> { }
-        public class CustomAuthorization : OpenIddictAuthorization<long, CustomApplication, CustomToken> { }
-        public class CustomScope : OpenIddictScope<long> { }
-        public class CustomToken : OpenIddictToken<long, CustomApplication, CustomAuthorization> { }
+        public class CustomApplication : OpenIddictEntityFrameworkCoreApplication<long, CustomAuthorization, CustomToken> { }
+        public class CustomAuthorization : OpenIddictEntityFrameworkCoreAuthorization<long, CustomApplication, CustomToken> { }
+        public class CustomScope : OpenIddictEntityFrameworkCoreScope<long> { }
+        public class CustomToken : OpenIddictEntityFrameworkCoreToken<long, CustomApplication, CustomAuthorization> { }
 
         public class CustomDbContext : DbContext
         {

test/OpenIddict.EntityFrameworkCore.Tests/OpenIddictEntityFrameworkCoreExtensionsTests.cs

@@ -55,17 +55,17 @@ namespace OpenIddict.EntityFrameworkCore.Tests
             var provider = services.BuildServiceProvider();
             var options = provider.GetRequiredService<IOptionsMonitor<OpenIddictCoreOptions>>().CurrentValue;
 
-            Assert.Equal(typeof(OpenIddictApplication), options.DefaultApplicationType);
-            Assert.Equal(typeof(OpenIddictAuthorization), options.DefaultAuthorizationType);
-            Assert.Equal(typeof(OpenIddictScope), options.DefaultScopeType);
-            Assert.Equal(typeof(OpenIddictToken), options.DefaultTokenType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkCoreApplication), options.DefaultApplicationType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkCoreAuthorization), options.DefaultAuthorizationType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkCoreScope), options.DefaultScopeType);
+            Assert.Equal(typeof(OpenIddictEntityFrameworkCoreToken), options.DefaultTokenType);
         }
 
         [Theory]
-        [InlineData(typeof(IOpenIddictApplicationStoreResolver), typeof(OpenIddictApplicationStoreResolver))]
-        [InlineData(typeof(IOpenIddictAuthorizationStoreResolver), typeof(OpenIddictAuthorizationStoreResolver))]
-        [InlineData(typeof(IOpenIddictScopeStoreResolver), typeof(OpenIddictScopeStoreResolver))]
-        [InlineData(typeof(IOpenIddictTokenStoreResolver), typeof(OpenIddictTokenStoreResolver))]
+        [InlineData(typeof(IOpenIddictApplicationStoreResolver), typeof(OpenIddictEntityFrameworkCoreApplicationStoreResolver))]
+        [InlineData(typeof(IOpenIddictAuthorizationStoreResolver), typeof(OpenIddictEntityFrameworkCoreAuthorizationStoreResolver))]
+        [InlineData(typeof(IOpenIddictScopeStoreResolver), typeof(OpenIddictEntityFrameworkCoreScopeStoreResolver))]
+        [InlineData(typeof(IOpenIddictTokenStoreResolver), typeof(OpenIddictEntityFrameworkCoreTokenStoreResolver))]
         public void UseEntityFrameworkCore_RegistersEntityFrameworkCoreStoreResolvers(Type serviceType, Type implementationType)
         {
             // Arrange
@@ -81,10 +81,10 @@ namespace OpenIddict.EntityFrameworkCore.Tests
         }
 
         [Theory]
-        [InlineData(typeof(OpenIddictApplicationStoreResolver.TypeResolutionCache))]
-        [InlineData(typeof(OpenIddictAuthorizationStoreResolver.TypeResolutionCache))]
-        [InlineData(typeof(OpenIddictScopeStoreResolver.TypeResolutionCache))]
-        [InlineData(typeof(OpenIddictTokenStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictEntityFrameworkCoreApplicationStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictEntityFrameworkCoreAuthorizationStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictEntityFrameworkCoreScopeStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictEntityFrameworkCoreTokenStoreResolver.TypeResolutionCache))]
         public void UseEntityFrameworkCore_RegistersEntityFrameworkCoreStoreResolverCaches(Type type)
         {
             // Arrange
@@ -100,10 +100,10 @@ namespace OpenIddict.EntityFrameworkCore.Tests
         }
 
         [Theory]
-        [InlineData(typeof(OpenIddictApplicationStore<,,,,>))]
-        [InlineData(typeof(OpenIddictAuthorizationStore<,,,,>))]
-        [InlineData(typeof(OpenIddictScopeStore<,,>))]
-        [InlineData(typeof(OpenIddictTokenStore<,,,,>))]
+        [InlineData(typeof(OpenIddictEntityFrameworkCoreApplicationStore<,,,,>))]
+        [InlineData(typeof(OpenIddictEntityFrameworkCoreAuthorizationStore<,,,,>))]
+        [InlineData(typeof(OpenIddictEntityFrameworkCoreScopeStore<,,>))]
+        [InlineData(typeof(OpenIddictEntityFrameworkCoreTokenStore<,,,,>))]
         public void UseEntityFrameworkCore_RegistersEntityFrameworkCoreStore(Type type)
         {
             // Arrange

test/OpenIddict.EntityFrameworkCore.Tests/OpenIddictEntityFrameworkCoreHelpersTests.cs

@@ -20,13 +20,13 @@ namespace OpenIddict.EntityFrameworkCore.Tests
         {
             // Arrange
             var builder = new Mock<ModelBuilder>(new ConventionSet());
-            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictApplication>>()))
+            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictEntityFrameworkCoreApplication>>()))
                 .Returns(builder.Object);
-            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictAuthorization>>()))
+            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictEntityFrameworkCoreAuthorization>>()))
                 .Returns(builder.Object);
-            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictScope>>()))
+            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictEntityFrameworkCoreScope>>()))
                 .Returns(builder.Object);
-            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictToken>>()))
+            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictEntityFrameworkCoreToken>>()))
                 .Returns(builder.Object);
 
             // Act
@@ -34,13 +34,13 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             // Assert
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictApplicationConfiguration<OpenIddictApplication, OpenIddictAuthorization, OpenIddictToken, string>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreApplicationConfiguration<OpenIddictEntityFrameworkCoreApplication, OpenIddictEntityFrameworkCoreAuthorization, OpenIddictEntityFrameworkCoreToken, string>>()), Times.Once());
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictAuthorizationConfiguration<OpenIddictAuthorization, OpenIddictApplication, OpenIddictToken, string>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreAuthorizationConfiguration<OpenIddictEntityFrameworkCoreAuthorization, OpenIddictEntityFrameworkCoreApplication, OpenIddictEntityFrameworkCoreToken, string>>()), Times.Once());
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictScopeConfiguration<OpenIddictScope, string>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreScopeConfiguration<OpenIddictEntityFrameworkCoreScope, string>>()), Times.Once());
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictTokenConfiguration<OpenIddictToken, OpenIddictApplication, OpenIddictAuthorization, string>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreTokenConfiguration<OpenIddictEntityFrameworkCoreToken, OpenIddictEntityFrameworkCoreApplication, OpenIddictEntityFrameworkCoreAuthorization, string>>()), Times.Once());
         }
 
         [Fact]
@@ -48,13 +48,13 @@ namespace OpenIddict.EntityFrameworkCore.Tests
         {
             // Arrange
             var builder = new Mock<ModelBuilder>(new ConventionSet());
-            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictApplication<long>>>()))
+            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictEntityFrameworkCoreApplication<long>>>()))
                 .Returns(builder.Object);
-            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictAuthorization<long>>>()))
+            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictEntityFrameworkCoreAuthorization<long>>>()))
                 .Returns(builder.Object);
-            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictScope<long>>>()))
+            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictEntityFrameworkCoreScope<long>>>()))
                 .Returns(builder.Object);
-            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictToken<long>>>()))
+            builder.Setup(mock => mock.ApplyConfiguration(It.IsAny<IEntityTypeConfiguration<OpenIddictEntityFrameworkCoreToken<long>>>()))
                 .Returns(builder.Object);
 
             // Act
@@ -62,13 +62,13 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             // Assert
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictApplicationConfiguration<OpenIddictApplication<long>, OpenIddictAuthorization<long>, OpenIddictToken<long>, long>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreApplicationConfiguration<OpenIddictEntityFrameworkCoreApplication<long>, OpenIddictEntityFrameworkCoreAuthorization<long>, OpenIddictEntityFrameworkCoreToken<long>, long>>()), Times.Once());
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictAuthorizationConfiguration<OpenIddictAuthorization<long>, OpenIddictApplication<long>, OpenIddictToken<long>, long>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreAuthorizationConfiguration<OpenIddictEntityFrameworkCoreAuthorization<long>, OpenIddictEntityFrameworkCoreApplication<long>, OpenIddictEntityFrameworkCoreToken<long>, long>>()), Times.Once());
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictScopeConfiguration<OpenIddictScope<long>, long>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreScopeConfiguration<OpenIddictEntityFrameworkCoreScope<long>, long>>()), Times.Once());
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictTokenConfiguration<OpenIddictToken<long>, OpenIddictApplication<long>, OpenIddictAuthorization<long>, long>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreTokenConfiguration<OpenIddictEntityFrameworkCoreToken<long>, OpenIddictEntityFrameworkCoreApplication<long>, OpenIddictEntityFrameworkCoreAuthorization<long>, long>>()), Times.Once());
         }
 
         [Fact]
@@ -90,18 +90,18 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             // Assert
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictApplicationConfiguration<CustomApplication, CustomAuthorization, CustomToken, Guid>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreApplicationConfiguration<CustomApplication, CustomAuthorization, CustomToken, Guid>>()), Times.Once());
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictAuthorizationConfiguration<CustomAuthorization, CustomApplication, CustomToken, Guid>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreAuthorizationConfiguration<CustomAuthorization, CustomApplication, CustomToken, Guid>>()), Times.Once());
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictScopeConfiguration<CustomScope, Guid>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreScopeConfiguration<CustomScope, Guid>>()), Times.Once());
             builder.Verify(mock => mock.ApplyConfiguration(
-                It.IsAny<OpenIddictTokenConfiguration<CustomToken, CustomApplication, CustomAuthorization, Guid>>()), Times.Once());
+                It.IsAny<OpenIddictEntityFrameworkCoreTokenConfiguration<CustomToken, CustomApplication, CustomAuthorization, Guid>>()), Times.Once());
         }
 
-        public class CustomApplication : OpenIddictApplication<Guid, CustomAuthorization, CustomToken> { }
-        public class CustomAuthorization : OpenIddictAuthorization<Guid, CustomApplication, CustomToken> { }
-        public class CustomScope : OpenIddictScope<Guid> { }
-        public class CustomToken : OpenIddictToken<Guid, CustomApplication, CustomAuthorization> { }
+        public class CustomApplication : OpenIddictEntityFrameworkCoreApplication<Guid, CustomAuthorization, CustomToken> { }
+        public class CustomAuthorization : OpenIddictEntityFrameworkCoreAuthorization<Guid, CustomApplication, CustomToken> { }
+        public class CustomScope : OpenIddictEntityFrameworkCoreScope<Guid> { }
+        public class CustomToken : OpenIddictEntityFrameworkCoreToken<Guid, CustomApplication, CustomAuthorization> { }
     }
 }

test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs → test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictEntityFrameworkCoreApplicationStoreResolverTests.cs

@@ -14,11 +14,11 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFrameworkCore.Models;
 using Xunit;
-using static OpenIddict.EntityFrameworkCore.OpenIddictApplicationStoreResolver;
+using static OpenIddict.EntityFrameworkCore.OpenIddictEntityFrameworkCoreApplicationStoreResolver;
 
 namespace OpenIddict.EntityFrameworkCore.Tests
 {
-    public class OpenIddictApplicationStoreResolverTests
+    public class OpenIddictEntityFrameworkCoreApplicationStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -29,7 +29,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomApplication>());
@@ -43,7 +43,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomApplication>());
@@ -51,8 +51,8 @@ namespace OpenIddict.EntityFrameworkCore.Tests
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified application type is not compatible with the Entity Framework Core stores.")
                 .Append("When enabling the Entity Framework Core stores, make sure you use the built-in ")
-                .Append("'OpenIddictApplication' entity (from the 'OpenIddict.EntityFrameworkCore.Models' package) ")
-                .Append("or a custom entity that inherits from the generic 'OpenIddictApplication' entity.")
+                .Append("'OpenIddictEntityFrameworkCoreApplication' entity or a custom entity that inherits ")
+                .Append("from the generic 'OpenIddictEntityFrameworkCoreApplication' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -69,10 +69,10 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
-            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictApplication>());
+            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictEntityFrameworkCoreApplication>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("No Entity Framework Core context was specified in the OpenIddict options.")
@@ -96,23 +96,23 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyApplication>());
         }
 
-        private static OpenIddictApplicationStore<MyApplication, MyAuthorization, MyToken, DbContext, long> CreateStore() 
-            => new Mock<OpenIddictApplicationStore<MyApplication, MyAuthorization, MyToken, DbContext, long>>(
+        private static OpenIddictEntityFrameworkCoreApplicationStore<MyApplication, MyAuthorization, MyToken, DbContext, long> CreateStore() 
+            => new Mock<OpenIddictEntityFrameworkCoreApplicationStore<MyApplication, MyAuthorization, MyToken, DbContext, long>>(
                 Mock.Of<IMemoryCache>(),
                 Mock.Of<DbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>()).Object;
 
         public class CustomApplication { }
 
-        public class MyApplication : OpenIddictApplication<long, MyAuthorization, MyToken> { }
-        public class MyAuthorization : OpenIddictAuthorization<long, MyApplication, MyToken> { }
-        public class MyScope : OpenIddictScope<long> { }
-        public class MyToken : OpenIddictToken<long, MyApplication, MyAuthorization> { }
+        public class MyApplication : OpenIddictEntityFrameworkCoreApplication<long, MyAuthorization, MyToken> { }
+        public class MyAuthorization : OpenIddictEntityFrameworkCoreAuthorization<long, MyApplication, MyToken> { }
+        public class MyScope : OpenIddictEntityFrameworkCoreScope<long> { }
+        public class MyToken : OpenIddictEntityFrameworkCoreToken<long, MyApplication, MyAuthorization> { }
     }
 }

test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs → test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictEntityFrameworkCoreAuthorizationStoreResolverTests.cs

@@ -14,11 +14,11 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFrameworkCore.Models;
 using Xunit;
-using static OpenIddict.EntityFrameworkCore.OpenIddictAuthorizationStoreResolver;
+using static OpenIddict.EntityFrameworkCore.OpenIddictEntityFrameworkCoreAuthorizationStoreResolver;
 
 namespace OpenIddict.EntityFrameworkCore.Tests
 {
-    public class OpenIddictAuthorizationStoreResolverTests
+    public class OpenIddictEntityFrameworkCoreAuthorizationStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -29,7 +29,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomAuthorization>());
@@ -43,7 +43,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomAuthorization>());
@@ -51,8 +51,8 @@ namespace OpenIddict.EntityFrameworkCore.Tests
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified authorization type is not compatible with the Entity Framework Core stores.")
                 .Append("When enabling the Entity Framework Core stores, make sure you use the built-in ")
-                .Append("'OpenIddictAuthorization' entity (from the 'OpenIddict.EntityFrameworkCore.Models' package) ")
-                .Append("or a custom entity that inherits from the generic 'OpenIddictAuthorization' entity.")
+                .Append("'OpenIddictEntityFrameworkCoreAuthorization' entity or a custom entity that inherits ")
+                .Append("from the generic 'OpenIddictEntityFrameworkCoreAuthorization' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -69,10 +69,10 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
-            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictAuthorization>());
+            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictEntityFrameworkCoreAuthorization>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("No Entity Framework Core context was specified in the OpenIddict options.")
@@ -96,23 +96,23 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyAuthorization>());
         }
 
-        private static OpenIddictAuthorizationStore<MyAuthorization, MyApplication, MyToken, DbContext, long> CreateStore()
-            => new Mock<OpenIddictAuthorizationStore<MyAuthorization, MyApplication, MyToken, DbContext, long>>(
+        private static OpenIddictEntityFrameworkCoreAuthorizationStore<MyAuthorization, MyApplication, MyToken, DbContext, long> CreateStore()
+            => new Mock<OpenIddictEntityFrameworkCoreAuthorizationStore<MyAuthorization, MyApplication, MyToken, DbContext, long>>(
                 Mock.Of<IMemoryCache>(),
                 Mock.Of<DbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>()).Object;
 
         public class CustomAuthorization { }
 
-        public class MyApplication : OpenIddictApplication<long, MyAuthorization, MyToken> { }
-        public class MyAuthorization : OpenIddictAuthorization<long, MyApplication, MyToken> { }
-        public class MyScope : OpenIddictScope<long> { }
-        public class MyToken : OpenIddictToken<long, MyApplication, MyAuthorization> { }
+        public class MyApplication : OpenIddictEntityFrameworkCoreApplication<long, MyAuthorization, MyToken> { }
+        public class MyAuthorization : OpenIddictEntityFrameworkCoreAuthorization<long, MyApplication, MyToken> { }
+        public class MyScope : OpenIddictEntityFrameworkCoreScope<long> { }
+        public class MyToken : OpenIddictEntityFrameworkCoreToken<long, MyApplication, MyAuthorization> { }
     }
 }

test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs → test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictEntityFrameworkCoreScopeStoreResolverTests.cs

@@ -14,11 +14,11 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFrameworkCore.Models;
 using Xunit;
-using static OpenIddict.EntityFrameworkCore.OpenIddictScopeStoreResolver;
+using static OpenIddict.EntityFrameworkCore.OpenIddictEntityFrameworkCoreScopeStoreResolver;
 
 namespace OpenIddict.EntityFrameworkCore.Tests
 {
-    public class OpenIddictScopeStoreResolverTests
+    public class OpenIddictEntityFrameworkCoreScopeStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -29,7 +29,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomScope>());
@@ -43,7 +43,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomScope>());
@@ -51,8 +51,8 @@ namespace OpenIddict.EntityFrameworkCore.Tests
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified scope type is not compatible with the Entity Framework Core stores.")
                 .Append("When enabling the Entity Framework Core stores, make sure you use the built-in ")
-                .Append("'OpenIddictScope' entity (from the 'OpenIddict.EntityFrameworkCore.Models' package) ")
-                .Append("or a custom entity that inherits from the generic 'OpenIddictScope' entity.")
+                .Append("'OpenIddictEntityFrameworkCoreScope' entity or a custom entity that inherits ")
+                .Append("from the generic 'OpenIddictEntityFrameworkCoreScope' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -69,10 +69,10 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
-            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictScope>());
+            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictEntityFrameworkCoreScope>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("No Entity Framework Core context was specified in the OpenIddict options.")
@@ -96,23 +96,23 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyScope>());
         }
 
-        private static OpenIddictScopeStore<MyScope, DbContext, long> CreateStore()
-            => new Mock<OpenIddictScopeStore<MyScope, DbContext, long>>(
+        private static OpenIddictEntityFrameworkCoreScopeStore<MyScope, DbContext, long> CreateStore()
+            => new Mock<OpenIddictEntityFrameworkCoreScopeStore<MyScope, DbContext, long>>(
                 Mock.Of<IMemoryCache>(),
                 Mock.Of<DbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>()).Object;
 
         public class CustomScope { }
 
-        public class MyApplication : OpenIddictApplication<long, MyAuthorization, MyToken> { }
-        public class MyAuthorization : OpenIddictAuthorization<long, MyApplication, MyToken> { }
-        public class MyScope : OpenIddictScope<long> { }
-        public class MyToken : OpenIddictToken<long, MyApplication, MyAuthorization> { }
+        public class MyApplication : OpenIddictEntityFrameworkCoreApplication<long, MyAuthorization, MyToken> { }
+        public class MyAuthorization : OpenIddictEntityFrameworkCoreAuthorization<long, MyApplication, MyToken> { }
+        public class MyScope : OpenIddictEntityFrameworkCoreScope<long> { }
+        public class MyToken : OpenIddictEntityFrameworkCoreToken<long, MyApplication, MyAuthorization> { }
     }
 }

test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs → test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictEntityFrameworkCoreTokenStoreResolverTests.cs

@@ -14,11 +14,11 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFrameworkCore.Models;
 using Xunit;
-using static OpenIddict.EntityFrameworkCore.OpenIddictTokenStoreResolver;
+using static OpenIddict.EntityFrameworkCore.OpenIddictEntityFrameworkCoreTokenStoreResolver;
 
 namespace OpenIddict.EntityFrameworkCore.Tests
 {
-    public class OpenIddictTokenStoreResolverTests
+    public class OpenIddictEntityFrameworkCoreTokenStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -29,7 +29,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomToken>());
@@ -43,7 +43,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomToken>());
@@ -51,8 +51,8 @@ namespace OpenIddict.EntityFrameworkCore.Tests
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified token type is not compatible with the Entity Framework Core stores.")
                 .Append("When enabling the Entity Framework Core stores, make sure you use the built-in ")
-                .Append("'OpenIddictToken' entity (from the 'OpenIddict.EntityFrameworkCore.Models' package) ")
-                .Append("or a custom entity that inherits from the generic 'OpenIddictToken' entity.")
+                .Append("'OpenIddictEntityFrameworkCoreToken' entity or a custom entity that inherits ")
+                .Append("from the generic 'OpenIddictEntityFrameworkCoreToken' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -69,10 +69,10 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
-            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictToken>());
+            var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictEntityFrameworkCoreToken>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("No Entity Framework Core context was specified in the OpenIddict options.")
@@ -96,23 +96,23 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
+            var resolver = new OpenIddictEntityFrameworkCoreTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyToken>());
         }
 
-        private static OpenIddictTokenStore<MyToken, MyApplication, MyAuthorization, DbContext, long> CreateStore()
-            => new Mock<OpenIddictTokenStore<MyToken, MyApplication, MyAuthorization, DbContext, long>>(
+        private static OpenIddictEntityFrameworkCoreTokenStore<MyToken, MyApplication, MyAuthorization, DbContext, long> CreateStore()
+            => new Mock<OpenIddictEntityFrameworkCoreTokenStore<MyToken, MyApplication, MyAuthorization, DbContext, long>>(
                 Mock.Of<IMemoryCache>(),
                 Mock.Of<DbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>()).Object;
 
         public class CustomToken { }
 
-        public class MyApplication : OpenIddictApplication<long, MyAuthorization, MyToken> { }
-        public class MyAuthorization : OpenIddictAuthorization<long, MyApplication, MyToken> { }
-        public class MyScope : OpenIddictScope<long> { }
-        public class MyToken : OpenIddictToken<long, MyApplication, MyAuthorization> { }
+        public class MyApplication : OpenIddictEntityFrameworkCoreApplication<long, MyAuthorization, MyToken> { }
+        public class MyAuthorization : OpenIddictEntityFrameworkCoreAuthorization<long, MyApplication, MyToken> { }
+        public class MyScope : OpenIddictEntityFrameworkCoreScope<long> { }
+        public class MyToken : OpenIddictEntityFrameworkCoreToken<long, MyApplication, MyAuthorization> { }
     }
 }

test/OpenIddict.MongoDb.Tests/OpenIddictMongoDbBuilderTests.cs

@@ -308,9 +308,9 @@ namespace OpenIddict.MongoDb.Tests
             return services;
         }
 
-        public class CustomApplication : OpenIddictApplication { }
-        public class CustomAuthorization : OpenIddictAuthorization { }
-        public class CustomScope : OpenIddictScope { }
-        public class CustomToken : OpenIddictToken { }
+        public class CustomApplication : OpenIddictMongoDbApplication { }
+        public class CustomAuthorization : OpenIddictMongoDbAuthorization { }
+        public class CustomScope : OpenIddictMongoDbScope { }
+        public class CustomToken : OpenIddictMongoDbToken { }
     }
 }

test/OpenIddict.MongoDb.Tests/OpenIddictMongoDbContextTests.cs

@@ -69,20 +69,20 @@ namespace OpenIddict.MongoDb.Tests
             var services = new ServiceCollection();
             var provider = services.BuildServiceProvider();
 
-            var manager = new Mock<IMongoIndexManager<OpenIddictApplication>>();
-            manager.Setup(mock => mock.CreateManyAsync(It.IsAny<IEnumerable<CreateIndexModel<OpenIddictApplication>>>(), It.IsAny<CancellationToken>()))
+            var manager = new Mock<IMongoIndexManager<OpenIddictMongoDbApplication>>();
+            manager.Setup(mock => mock.CreateManyAsync(It.IsAny<IEnumerable<CreateIndexModel<OpenIddictMongoDbApplication>>>(), It.IsAny<CancellationToken>()))
                 .Returns(async delegate
                 {
                     await Task.Delay(TimeSpan.FromMilliseconds(1000));
                     return new[] { string.Empty };
                 });
 
-            var collection = new Mock<IMongoCollection<OpenIddictApplication>>();
+            var collection = new Mock<IMongoCollection<OpenIddictMongoDbApplication>>();
             collection.SetupGet(mock => mock.Indexes)
                 .Returns(manager.Object);
 
             var database = GetDatabase();
-            database.Setup(mock => mock.GetCollection<OpenIddictApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
+            database.Setup(mock => mock.GetCollection<OpenIddictMongoDbApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
                 .Returns(collection.Object);
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictMongoDbOptions>>(
@@ -208,10 +208,10 @@ namespace OpenIddict.MongoDb.Tests
             await context.GetDatabaseAsync(CancellationToken.None);
 
             // Assert
-            database.Verify(mock => mock.GetCollection<OpenIddictApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Never());
-            database.Verify(mock => mock.GetCollection<OpenIddictAuthorization>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Never());
-            database.Verify(mock => mock.GetCollection<OpenIddictScope>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Never());
-            database.Verify(mock => mock.GetCollection<OpenIddictToken>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Never());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Never());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbAuthorization>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Never());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbScope>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Never());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbToken>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Never());
         }
 
         [Fact]
@@ -234,10 +234,10 @@ namespace OpenIddict.MongoDb.Tests
             Assert.Same(database.Object, await context.GetDatabaseAsync(CancellationToken.None));
             Assert.Same(database.Object, await context.GetDatabaseAsync(CancellationToken.None));
 
-            database.Verify(mock => mock.GetCollection<OpenIddictApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
-            database.Verify(mock => mock.GetCollection<OpenIddictAuthorization>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
-            database.Verify(mock => mock.GetCollection<OpenIddictScope>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
-            database.Verify(mock => mock.GetCollection<OpenIddictToken>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbAuthorization>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbScope>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbToken>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
         }
 
         [Fact]
@@ -249,12 +249,12 @@ namespace OpenIddict.MongoDb.Tests
 
             var count = 0;
 
-            var collection = new Mock<IMongoCollection<OpenIddictApplication>>();
+            var collection = new Mock<IMongoCollection<OpenIddictMongoDbApplication>>();
             collection.SetupGet(mock => mock.Indexes)
-                .Returns(Mock.Of<IMongoIndexManager<OpenIddictApplication>>());
+                .Returns(Mock.Of<IMongoIndexManager<OpenIddictMongoDbApplication>>());
 
             var database = GetDatabase();
-            database.Setup(mock => mock.GetCollection<OpenIddictApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
+            database.Setup(mock => mock.GetCollection<OpenIddictMongoDbApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
                 .Callback(() => count++)
                 .Returns(delegate
                 {
@@ -278,38 +278,38 @@ namespace OpenIddict.MongoDb.Tests
             await Assert.ThrowsAsync<Exception>(async () => await context.GetDatabaseAsync(CancellationToken.None));
             Assert.Same(database.Object, await context.GetDatabaseAsync(CancellationToken.None));
 
-            database.Verify(mock => mock.GetCollection<OpenIddictApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Exactly(2));
-            database.Verify(mock => mock.GetCollection<OpenIddictAuthorization>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
-            database.Verify(mock => mock.GetCollection<OpenIddictScope>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
-            database.Verify(mock => mock.GetCollection<OpenIddictToken>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Exactly(2));
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbAuthorization>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbScope>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
+            database.Verify(mock => mock.GetCollection<OpenIddictMongoDbToken>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()), Times.Once());
         }
 
         private static Mock<IMongoDatabase> GetDatabase()
         {
-            var applications = new Mock<IMongoCollection<OpenIddictApplication>>();
+            var applications = new Mock<IMongoCollection<OpenIddictMongoDbApplication>>();
             applications.SetupGet(mock => mock.Indexes)
-                .Returns(Mock.Of<IMongoIndexManager<OpenIddictApplication>>());
+                .Returns(Mock.Of<IMongoIndexManager<OpenIddictMongoDbApplication>>());
 
-            var authorizations = new Mock<IMongoCollection<OpenIddictAuthorization>>();
+            var authorizations = new Mock<IMongoCollection<OpenIddictMongoDbAuthorization>>();
             authorizations.SetupGet(mock => mock.Indexes)
-                .Returns(Mock.Of<IMongoIndexManager<OpenIddictAuthorization>>());
+                .Returns(Mock.Of<IMongoIndexManager<OpenIddictMongoDbAuthorization>>());
 
-            var scopes = new Mock<IMongoCollection<OpenIddictScope>>();
+            var scopes = new Mock<IMongoCollection<OpenIddictMongoDbScope>>();
             scopes.SetupGet(mock => mock.Indexes)
-                .Returns(Mock.Of<IMongoIndexManager<OpenIddictScope>>());
+                .Returns(Mock.Of<IMongoIndexManager<OpenIddictMongoDbScope>>());
 
-            var tokens = new Mock<IMongoCollection<OpenIddictToken>>();
+            var tokens = new Mock<IMongoCollection<OpenIddictMongoDbToken>>();
             tokens.SetupGet(mock => mock.Indexes)
-                .Returns(Mock.Of<IMongoIndexManager<OpenIddictToken>>());
+                .Returns(Mock.Of<IMongoIndexManager<OpenIddictMongoDbToken>>());
 
             var database = new Mock<IMongoDatabase>();
-            database.Setup(mock => mock.GetCollection<OpenIddictApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
+            database.Setup(mock => mock.GetCollection<OpenIddictMongoDbApplication>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
                 .Returns(applications.Object);
-            database.Setup(mock => mock.GetCollection<OpenIddictAuthorization>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
+            database.Setup(mock => mock.GetCollection<OpenIddictMongoDbAuthorization>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
                 .Returns(authorizations.Object);
-            database.Setup(mock => mock.GetCollection<OpenIddictScope>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
+            database.Setup(mock => mock.GetCollection<OpenIddictMongoDbScope>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
                 .Returns(scopes.Object);
-            database.Setup(mock => mock.GetCollection<OpenIddictToken>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
+            database.Setup(mock => mock.GetCollection<OpenIddictMongoDbToken>(It.IsAny<string>(), It.IsAny<MongoCollectionSettings>()))
                 .Returns(tokens.Object);
 
             return database;

test/OpenIddict.MongoDb.Tests/OpenIddictMongoDbExtensionsTests.cs

@@ -55,17 +55,17 @@ namespace OpenIddict.MongoDb.Tests
             var provider = services.BuildServiceProvider();
             var options = provider.GetRequiredService<IOptionsMonitor<OpenIddictCoreOptions>>().CurrentValue;
 
-            Assert.Equal(typeof(OpenIddictApplication), options.DefaultApplicationType);
-            Assert.Equal(typeof(OpenIddictAuthorization), options.DefaultAuthorizationType);
-            Assert.Equal(typeof(OpenIddictScope), options.DefaultScopeType);
-            Assert.Equal(typeof(OpenIddictToken), options.DefaultTokenType);
+            Assert.Equal(typeof(OpenIddictMongoDbApplication), options.DefaultApplicationType);
+            Assert.Equal(typeof(OpenIddictMongoDbAuthorization), options.DefaultAuthorizationType);
+            Assert.Equal(typeof(OpenIddictMongoDbScope), options.DefaultScopeType);
+            Assert.Equal(typeof(OpenIddictMongoDbToken), options.DefaultTokenType);
         }
 
         [Theory]
-        [InlineData(typeof(IOpenIddictApplicationStoreResolver), typeof(OpenIddictApplicationStoreResolver))]
-        [InlineData(typeof(IOpenIddictAuthorizationStoreResolver), typeof(OpenIddictAuthorizationStoreResolver))]
-        [InlineData(typeof(IOpenIddictScopeStoreResolver), typeof(OpenIddictScopeStoreResolver))]
-        [InlineData(typeof(IOpenIddictTokenStoreResolver), typeof(OpenIddictTokenStoreResolver))]
+        [InlineData(typeof(IOpenIddictApplicationStoreResolver), typeof(OpenIddictMongoDbApplicationStoreResolver))]
+        [InlineData(typeof(IOpenIddictAuthorizationStoreResolver), typeof(OpenIddictMongoDbAuthorizationStoreResolver))]
+        [InlineData(typeof(IOpenIddictScopeStoreResolver), typeof(OpenIddictMongoDbScopeStoreResolver))]
+        [InlineData(typeof(IOpenIddictTokenStoreResolver), typeof(OpenIddictMongoDbTokenStoreResolver))]
         public void UseMongoDb_RegistersMongoDbStoreResolvers(Type serviceType, Type implementationType)
         {
             // Arrange
@@ -81,10 +81,10 @@ namespace OpenIddict.MongoDb.Tests
         }
 
         [Theory]
-        [InlineData(typeof(OpenIddictApplicationStore<>))]
-        [InlineData(typeof(OpenIddictAuthorizationStore<>))]
-        [InlineData(typeof(OpenIddictScopeStore<>))]
-        [InlineData(typeof(OpenIddictTokenStore<>))]
+        [InlineData(typeof(OpenIddictMongoDbApplicationStore<>))]
+        [InlineData(typeof(OpenIddictMongoDbAuthorizationStore<>))]
+        [InlineData(typeof(OpenIddictMongoDbScopeStore<>))]
+        [InlineData(typeof(OpenIddictMongoDbTokenStore<>))]
         public void UseMongoDb_RegistersMongoDbStore(Type type)
         {
             // Arrange

test/OpenIddict.MongoDb.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs → test/OpenIddict.MongoDb.Tests/Resolvers/OpenIddictMongoDbApplicationStoreResolverTests.cs

@@ -15,7 +15,7 @@ using Xunit;
 
 namespace OpenIddict.MongoDb.Tests
 {
-    public class OpenIddictApplicationStoreResolverTests
+    public class OpenIddictMongoDbApplicationStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -25,7 +25,7 @@ namespace OpenIddict.MongoDb.Tests
             services.AddSingleton(Mock.Of<IOpenIddictApplicationStore<CustomApplication>>());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbApplicationStoreResolver(provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomApplication>());
@@ -38,16 +38,16 @@ namespace OpenIddict.MongoDb.Tests
             var services = new ServiceCollection();
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbApplicationStoreResolver(provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomApplication>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified application type is not compatible with the MongoDB stores.")
-                .Append("When enabling the MongoDB stores, make sure you use the built-in 'OpenIddictApplication' ")
-                .Append("entity (from the 'OpenIddict.MongoDb.Models' package) or a custom entity ")
-                .Append("that inherits from the 'OpenIddictApplication' entity.")
+                .Append("When enabling the MongoDB stores, make sure you use the built-in ")
+                .Append("'OpenIddictMongoDbApplication' entity or a custom entity that inherits ")
+                .Append("from the 'OpenIddictMongoDbApplication' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -60,19 +60,19 @@ namespace OpenIddict.MongoDb.Tests
             services.AddSingleton(CreateStore());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbApplicationStoreResolver(provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyApplication>());
         }
 
-        private static OpenIddictApplicationStore<MyApplication> CreateStore() 
-            => new Mock<OpenIddictApplicationStore<MyApplication>>(
+        private static OpenIddictMongoDbApplicationStore<MyApplication> CreateStore() 
+            => new Mock<OpenIddictMongoDbApplicationStore<MyApplication>>(
                 Mock.Of<IOpenIddictMongoDbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictMongoDbOptions>>()).Object;
 
         public class CustomApplication { }
 
-        public class MyApplication : OpenIddictApplication { }
+        public class MyApplication : OpenIddictMongoDbApplication { }
     }
 }

test/OpenIddict.MongoDb.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs → test/OpenIddict.MongoDb.Tests/Resolvers/OpenIddictMongoDbAuthorizationStoreResolverTests.cs

@@ -15,7 +15,7 @@ using Xunit;
 
 namespace OpenIddict.MongoDb.Tests
 {
-    public class OpenIddictAuthorizationStoreResolverTests
+    public class OpenIddictMongoDbAuthorizationStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -25,7 +25,7 @@ namespace OpenIddict.MongoDb.Tests
             services.AddSingleton(Mock.Of<IOpenIddictAuthorizationStore<CustomAuthorization>>());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbAuthorizationStoreResolver(provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomAuthorization>());
@@ -38,16 +38,16 @@ namespace OpenIddict.MongoDb.Tests
             var services = new ServiceCollection();
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbAuthorizationStoreResolver(provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomAuthorization>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified authorization type is not compatible with the MongoDB stores.")
-                .Append("When enabling the MongoDB stores, make sure you use the built-in 'OpenIddictAuthorization' ")
-                .Append("entity (from the 'OpenIddict.MongoDb.Models' package) or a custom entity ")
-                .Append("that inherits from the 'OpenIddictAuthorization' entity.")
+                .Append("When enabling the MongoDB stores, make sure you use the built-in ")
+                .Append("'OpenIddictMongoDbAuthorization' entity or a custom entity that inherits ")
+                .Append("from the 'OpenIddictMongoDbAuthorization' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -60,19 +60,19 @@ namespace OpenIddict.MongoDb.Tests
             services.AddSingleton(CreateStore());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbAuthorizationStoreResolver(provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyAuthorization>());
         }
 
-        private static OpenIddictAuthorizationStore<MyAuthorization> CreateStore()
-            => new Mock<OpenIddictAuthorizationStore<MyAuthorization>>(
+        private static OpenIddictMongoDbAuthorizationStore<MyAuthorization> CreateStore()
+            => new Mock<OpenIddictMongoDbAuthorizationStore<MyAuthorization>>(
                 Mock.Of<IOpenIddictMongoDbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictMongoDbOptions>>()).Object;
 
         public class CustomAuthorization { }
 
-        public class MyAuthorization : OpenIddictAuthorization { }
+        public class MyAuthorization : OpenIddictMongoDbAuthorization { }
     }
 }

test/OpenIddict.MongoDb.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs → test/OpenIddict.MongoDb.Tests/Resolvers/OpenIddictMongoDbScopeStoreResolverTests.cs

@@ -15,7 +15,7 @@ using Xunit;
 
 namespace OpenIddict.MongoDb.Tests
 {
-    public class OpenIddictScopeStoreResolverTests
+    public class OpenIddictMongoDbScopeStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -25,7 +25,7 @@ namespace OpenIddict.MongoDb.Tests
             services.AddSingleton(Mock.Of<IOpenIddictScopeStore<CustomScope>>());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbScopeStoreResolver(provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomScope>());
@@ -38,16 +38,16 @@ namespace OpenIddict.MongoDb.Tests
             var services = new ServiceCollection();
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbScopeStoreResolver(provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomScope>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified scope type is not compatible with the MongoDB stores.")
-                .Append("When enabling the MongoDB stores, make sure you use the built-in 'OpenIddictScope' ")
-                .Append("entity (from the 'OpenIddict.MongoDb.Models' package) or a custom entity ")
-                .Append("that inherits from the 'OpenIddictScope' entity.")
+                .Append("When enabling the MongoDB stores, make sure you use the built-in ")
+                .Append("'OpenIddictMongoDbScope' entity or a custom entity that inherits ")
+                .Append("from the 'OpenIddictMongoDbScope' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -60,19 +60,19 @@ namespace OpenIddict.MongoDb.Tests
             services.AddSingleton(CreateStore());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbScopeStoreResolver(provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyScope>());
         }
 
-        private static OpenIddictScopeStore<MyScope> CreateStore()
-            => new Mock<OpenIddictScopeStore<MyScope>>(
+        private static OpenIddictMongoDbScopeStore<MyScope> CreateStore()
+            => new Mock<OpenIddictMongoDbScopeStore<MyScope>>(
                 Mock.Of<IOpenIddictMongoDbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictMongoDbOptions>>()).Object;
 
         public class CustomScope { }
 
-        public class MyScope : OpenIddictScope { }
+        public class MyScope : OpenIddictMongoDbScope { }
     }
 }

test/OpenIddict.MongoDb.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs → test/OpenIddict.MongoDb.Tests/Resolvers/OpenIddictMongoDbTokenStoreResolverTests.cs

@@ -15,7 +15,7 @@ using Xunit;
 
 namespace OpenIddict.MongoDb.Tests
 {
-    public class OpenIddictTokenStoreResolverTests
+    public class OpenIddictMongoDbTokenStoreResolverTests
     {
         [Fact]
         public void Get_ReturnsCustomStoreCorrespondingToTheSpecifiedTypeWhenAvailable()
@@ -25,7 +25,7 @@ namespace OpenIddict.MongoDb.Tests
             services.AddSingleton(Mock.Of<IOpenIddictTokenStore<CustomToken>>());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbTokenStoreResolver(provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomToken>());
@@ -38,16 +38,16 @@ namespace OpenIddict.MongoDb.Tests
             var services = new ServiceCollection();
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbTokenStoreResolver(provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomToken>());
 
             Assert.Equal(new StringBuilder()
                 .AppendLine("The specified token type is not compatible with the MongoDB stores.")
-                .Append("When enabling the MongoDB stores, make sure you use the built-in 'OpenIddictToken' ")
-                .Append("entity (from the 'OpenIddict.MongoDb.Models' package) or a custom entity ")
-                .Append("that inherits from the 'OpenIddictToken' entity.")
+                .Append("When enabling the MongoDB stores, make sure you use the built-in ")
+                .Append("'OpenIddictMongoDbToken' entity or a custom entity that inherits ")
+                .Append("from the 'OpenIddictMongoDbToken' entity.")
                 .ToString(), exception.Message);
         }
 
@@ -60,19 +60,19 @@ namespace OpenIddict.MongoDb.Tests
             services.AddSingleton(CreateStore());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(provider);
+            var resolver = new OpenIddictMongoDbTokenStoreResolver(provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyToken>());
         }
 
-        private static OpenIddictTokenStore<MyToken> CreateStore()
-            => new Mock<OpenIddictTokenStore<MyToken>>(
+        private static OpenIddictMongoDbTokenStore<MyToken> CreateStore()
+            => new Mock<OpenIddictMongoDbTokenStore<MyToken>>(
                 Mock.Of<IOpenIddictMongoDbContext>(),
                 Mock.Of<IOptionsMonitor<OpenIddictMongoDbOptions>>()).Object;
 
         public class CustomToken { }
 
-        public class MyToken : OpenIddictToken { }
+        public class MyToken : OpenIddictMongoDbToken { }
     }
 }