diff --git a/Microsoft.SCIM.PlaywrightTests/EndpointTests.cs b/Microsoft.SCIM.PlaywrightTests/EndpointTests.cs
new file mode 100644
index 00000000..cf635492
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/EndpointTests.cs
@@ -0,0 +1,174 @@
+using System.Text.Json;
+using Microsoft.Playwright.NUnit;
+using Microsoft.Playwright;
+
+namespace PlaywrightTests;
+
+[TestFixture]
+public class EndpointTests : PlaywrightTest
+{
+    private IAPIRequestContext? Request;
+    static string PROTOCOL = Environment.GetEnvironmentVariable("PROTOCOL") ?? "http";
+    static string SERVER = Environment.GetEnvironmentVariable("SERVER") ?? "localhost";
+    static string PORT = Environment.GetEnvironmentVariable("PORT") ?? ":5000";
+    static string API = Environment.GetEnvironmentVariable("API") ?? "scim";
+    private static string _baseUrl = $"{PROTOCOL}://{SERVER}{PORT}/{API}/";
+
+    [Test]
+    public async Task SchemaIsReturned()
+    {
+        var schemaResponse = await Request.GetAsync("Schemas");
+        Assert.True(schemaResponse.Ok);
+
+        var schemaJsonResponse = await schemaResponse.TextAsync();
+
+        Assert.IsFalse(string.IsNullOrWhiteSpace(schemaJsonResponse));
+        Assert.IsTrue(schemaJsonResponse.Contains("User Account"));
+    }
+
+    [Test]
+    public async Task GetEmptyUsers()
+    {
+        var emptyUsersResponse = await Request.GetAsync("Users");
+        Assert.True(emptyUsersResponse.Ok);
+
+        var emptyUsersJson = emptyUsersResponse.JsonAsync().Result;
+        Assert.True(emptyUsersJson.HasValue);
+        Assert.True(emptyUsersJson!.Value.TryGetProperty("totalResults", out var totalResults));
+        Assert.That(totalResults.GetInt32(), Is.EqualTo(0));
+        Assert.True(emptyUsersJson.Value.TryGetProperty("itemsPerPage", out var itemsPerPage));
+        Assert.That(itemsPerPage.GetInt32(), Is.EqualTo(0));
+        Assert.True(emptyUsersJson.Value.TryGetProperty("schemas", out var schemas));
+        Assert.That(schemas.GetArrayLength(), Is.EqualTo(1));
+        Assert.True(emptyUsersJson.Value.TryGetProperty("Resources", out var resources));
+        Assert.That(resources.GetArrayLength(), Is.EqualTo(0));
+        Assert.That(schemas[0].ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(schemas[0].GetString(), Is.EqualTo("urn:ietf:params:scim:api:messages:2.0:ListResponse"));
+    }
+
+    [Test]
+    public async Task GetEmptyGroups()
+    {
+        var emptyGroupsResponse = await Request.GetAsync("Groups");
+        Assert.True(emptyGroupsResponse.Ok);
+
+        var emptyGroupsJson = emptyGroupsResponse.JsonAsync().Result;
+        Assert.True(emptyGroupsJson.HasValue);
+        Assert.True(emptyGroupsJson!.Value.TryGetProperty("totalResults", out var totalResults));
+        Assert.That(totalResults.GetInt32(), Is.EqualTo(0));
+        Assert.True(emptyGroupsJson.Value.TryGetProperty("itemsPerPage", out var itemsPerPage));
+        Assert.That(itemsPerPage.GetInt32(), Is.EqualTo(0));
+        Assert.True(emptyGroupsJson.Value.TryGetProperty("schemas", out var schemas));
+        Assert.That(schemas.GetArrayLength(), Is.EqualTo(1));
+        Assert.True(emptyGroupsJson.Value.TryGetProperty("Resources", out var resources));
+        Assert.That(resources.GetArrayLength(), Is.EqualTo(0));
+        Assert.That(schemas[0].ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(schemas[0].GetString(), Is.EqualTo("urn:ietf:params:scim:api:messages:2.0:ListResponse"));
+
+        foreach (var resource in resources.EnumerateArray())
+        {
+            Assert.True(resource.TryGetProperty("endpoint", out _));
+            Assert.True(resource.TryGetProperty("name", out _));
+            Assert.True(resource.TryGetProperty("meta", out _));
+            Assert.True(resource.TryGetProperty("schema", out _));
+            Assert.True(resource.TryGetProperty("schemas", out _));
+            Assert.True(resource.TryGetProperty("id", out _));
+        }
+    }
+
+    [Test]
+    public async Task GetResourceTypes()
+    {
+        var resourceTypesResponse = await Request.GetAsync("ResourceTypes");
+        Assert.True(resourceTypesResponse.Ok);
+
+        var resourceTypesResponseJson = resourceTypesResponse.JsonAsync().Result;
+        Assert.True(resourceTypesResponseJson.HasValue);
+        Assert.True(resourceTypesResponseJson!.Value.TryGetProperty("totalResults", out var totalResults));
+        Assert.That(totalResults.GetInt32(), Is.EqualTo(2));
+        Assert.True(resourceTypesResponseJson.Value.TryGetProperty("itemsPerPage", out var itemsPerPage));
+        Assert.That(itemsPerPage.GetInt32(), Is.EqualTo(2));
+        Assert.True(resourceTypesResponseJson.Value.TryGetProperty("startIndex", out var startIndex));
+        Assert.That(startIndex.GetInt32(), Is.EqualTo(1));
+        Assert.True(resourceTypesResponseJson.Value.TryGetProperty("schemas", out var schemas));
+        Assert.That(schemas.GetArrayLength(), Is.EqualTo(1));
+        Assert.True(resourceTypesResponseJson.Value.TryGetProperty("Resources", out var resources));
+        Assert.That(resources.GetArrayLength(), Is.EqualTo(2));
+        Assert.That(schemas[0].ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(schemas[0].GetString(), Is.EqualTo("urn:ietf:params:scim:api:messages:2.0:ListResponse"));
+    }
+
+    [Test]
+    public async Task GetServiceProviderConfig()
+    {
+        var serviceProviderConfigResponse = await Request.GetAsync("ServiceProviderConfig");
+        Assert.True(serviceProviderConfigResponse.Ok);
+
+        var serviceProviderConfigResponseJson = serviceProviderConfigResponse.JsonAsync().Result;
+        Assert.True(serviceProviderConfigResponseJson.HasValue);
+        Assert.True(serviceProviderConfigResponseJson!.Value.TryGetProperty("authenticationSchemes", out var authenticationSchemes));
+        Assert.True(serviceProviderConfigResponseJson.Value.TryGetProperty("meta", out var meta));
+        Assert.True(serviceProviderConfigResponseJson.Value.TryGetProperty("bulk", out var bulk));
+        Assert.True(serviceProviderConfigResponseJson.Value.TryGetProperty("eTag", out var eTag));
+        Assert.True(serviceProviderConfigResponseJson.Value.TryGetProperty("filter", out var filter));
+        Assert.True(serviceProviderConfigResponseJson.Value.TryGetProperty("patch", out var patch));
+        Assert.True(serviceProviderConfigResponseJson.Value.TryGetProperty("sort", out var sort));
+        Assert.True(serviceProviderConfigResponseJson.Value.TryGetProperty("schemas", out var xmlDataFormat));
+    }
+
+
+
+    [SetUp]
+    public async Task SetUpAPITesting()
+    {
+        await CreateAPIRequestContext();
+        await GetAccessToken();
+    }
+
+    private async Task CreateAPIRequestContext()
+    {
+        // Assuming personal access token available in the environment.
+
+        Request = await this.Playwright.APIRequest.NewContextAsync(new()
+        {
+            // All requests we send go to this API endpoint.
+            BaseURL = _baseUrl,
+        });
+    }
+
+    private async Task GetAccessToken()
+    {
+        var headers = new Dictionary<string, string>();
+        var response = await Request.GetAsync("Token");
+        Assert.True(response.Ok);
+
+        var tokenJsonResponse = response.JsonAsync().Result;
+        if (!tokenJsonResponse.HasValue)
+        {
+            throw new Exception("No token found in response.");
+        }
+
+        if (tokenJsonResponse.Value.TryGetProperty("token", out var token) == true)
+        {
+            if (token.ValueKind == JsonValueKind.String)
+            {
+                // Add authorization token to all requests.
+                // Assuming personal access token available in the environment.
+                headers.Add("Authorization", $"Bearer {token}");
+                await Request.DisposeAsync();
+                Request = await this.Playwright.APIRequest.NewContextAsync(new()
+                {
+                    // All requests we send go to this API endpoint.
+                    BaseURL = _baseUrl,
+                    ExtraHTTPHeaders = headers
+                });
+            }
+        }
+    }
+
+    [TearDown]
+    public async Task TearDownAPITesting()
+    {
+        await Request.DisposeAsync();
+    }
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/GroupTests.cs b/Microsoft.SCIM.PlaywrightTests/GroupTests.cs
new file mode 100644
index 00000000..faa35c3f
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/GroupTests.cs
@@ -0,0 +1,475 @@
+using System.Text.Json;
+using Microsoft.Playwright.NUnit;
+using Microsoft.Playwright;
+using PlaywrightTests.Utils;
+
+namespace PlaywrightTests;
+
+[TestFixture]
+public class GroupTests : PlaywrightTest
+{
+    private IAPIRequestContext? Request;
+    static string PROTOCOL = Environment.GetEnvironmentVariable("PROTOCOL") ?? "http";
+    static string SERVER = Environment.GetEnvironmentVariable("SERVER") ?? "localhost";
+    static string PORT = Environment.GetEnvironmentVariable("PORT") ?? ":5000";
+    static string API = Environment.GetEnvironmentVariable("API") ?? "scim";
+    private static string _baseUrl = $"{PROTOCOL}://{SERVER}{PORT}/{API}/";
+
+    [Test, Order(1)]
+    public async Task PostEmptyGroup()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/group1.json");
+        var groupResponse = await Request.PostAsync("Groups",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.EqualTo(201));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        SharedTestContext.Group1 = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.Group1));
+        Assert.True(groupJson.Value.TryGetProperty("displayName", out var displayName));
+        Assert.That(displayName.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.False(string.IsNullOrWhiteSpace(displayName.GetString()));
+        ;
+        Assert.True(groupJson.Value.TryGetProperty("members", out var members));
+        Assert.That(members.GetArrayLength(), Is.EqualTo(0));
+        Assert.True(groupJson.Value.TryGetProperty("schemas", out var schemas));
+        Assert.That(schemas.GetArrayLength(), Is.EqualTo(1));
+        Assert.That(schemas[0].ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(schemas[0].GetString(), Is.EqualTo("urn:ietf:params:scim:schemas:core:2.0:Group"));
+        Assert.True(groupJson.Value.TryGetProperty("externalId", out var externalId));
+        Assert.That(externalId.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.False(string.IsNullOrWhiteSpace(externalId.GetString()));
+        Assert.Pass($"Group 1 with ID '{SharedTestContext.Group1}' added!");
+    }
+
+    [Test, Order(1)]
+    public async Task CreateGroup2Users()
+    {
+        var data3 = await JsonLoader.LoadJsonDataAsync("./json/user3.json");
+        var user3Response = await Request.PostAsync("Users",
+            new()
+            {
+                DataString = data3,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(user3Response.Ok);
+        Assert.That(user3Response.Status, Is.EqualTo(201));
+        var user3Json = await user3Response.JsonAsync();
+        Assert.True(user3Json.HasValue);
+        Assert.True(user3Json!.Value.TryGetProperty("id", out var id3));
+        Assert.That(id3.ValueKind, Is.EqualTo(JsonValueKind.String));
+        SharedTestContext.User3 = id3.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.User3));
+
+
+        var data4 = await JsonLoader.LoadJsonDataAsync("./json/user4.json");
+        var user4Response = await Request.PostAsync("Users",
+            new()
+            {
+                DataString = data4,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(user4Response.Ok);
+        Assert.That(user4Response.Status, Is.EqualTo(201));
+
+        var user4Json = await user4Response.JsonAsync();
+        Assert.True(user4Json.HasValue);
+        Assert.True(user4Json!.Value.TryGetProperty("id", out var id4));
+        Assert.That(id4.ValueKind, Is.EqualTo(JsonValueKind.String));
+        SharedTestContext.User4 = id4.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.User4));
+
+
+        Assert.Pass($"User3 and User4 with IDs '{SharedTestContext.User3}', '{SharedTestContext.User4}' added!");
+    }
+
+    [Test, Order(2)]
+    public async Task PostGroup2WithMembers()
+    {
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.User3));
+        var data = await JsonLoader.LoadJsonDataAsync("./json/group2.json", "id3", SharedTestContext.User3!);
+        var groupResponse = await Request.PostAsync("Groups",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.EqualTo(201));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        SharedTestContext.Group2 = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.Group2));
+        Assert.True(groupJson.Value.TryGetProperty("displayName", out var displayName));
+        Assert.That(displayName.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.False(string.IsNullOrWhiteSpace(displayName.GetString()));
+
+        // Check if members were added
+        Assert.True(groupJson.Value.TryGetProperty("members", out var members));
+        Assert.That(members.GetArrayLength(), Is.EqualTo(1));
+        Assert.True(members[0].TryGetProperty("value", out var value));
+        Assert.That(value.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.False(string.IsNullOrWhiteSpace(value.GetString()));
+
+        Assert.True(groupJson.Value.TryGetProperty("schemas", out var schemas));
+        Assert.That(schemas.GetArrayLength(), Is.EqualTo(1));
+        Assert.That(schemas[0].ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(schemas[0].GetString(), Is.EqualTo("urn:ietf:params:scim:schemas:core:2.0:Group"));
+        Assert.True(groupJson.Value.TryGetProperty("externalId", out var externalId));
+        Assert.That(externalId.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.False(string.IsNullOrWhiteSpace(externalId.GetString()));
+        Assert.Pass($"Group 2 with ID '{SharedTestContext.Group2}' added!");
+    }
+
+    [Test, Order(3)]
+    public async Task GetGroups()
+    {
+        var groupsResponse = await Request.GetAsync("Groups");
+        Assert.True(groupsResponse.Ok);
+        Assert.That(groupsResponse.Status, Is.EqualTo(200));
+
+        var groupsJson = await groupsResponse.JsonAsync();
+        Assert.True(groupsJson.HasValue);
+        Assert.True(groupsJson!.Value.TryGetProperty("totalResults", out var totalResults));
+        Assert.That(totalResults.GetInt32(), Is.EqualTo(2));
+        Assert.True(groupsJson.Value.TryGetProperty("itemsPerPage", out var itemsPerPage));
+        Assert.That(itemsPerPage.GetInt32(), Is.EqualTo(2));
+        Assert.True(groupsJson.Value.TryGetProperty("startIndex", out var startIndex));
+        Assert.That(startIndex.GetInt32(), Is.EqualTo(1));
+        Assert.True(groupsJson.Value.TryGetProperty("schemas", out var schemas));
+        Assert.That(schemas.GetArrayLength(), Is.EqualTo(1));
+        Assert.True(groupsJson.Value.TryGetProperty("Resources", out var resources));
+        Assert.That(resources.GetArrayLength(), Is.EqualTo(2));
+        Assert.That(schemas[0].ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(schemas[0].GetString(), Is.EqualTo("urn:ietf:params:scim:api:messages:2.0:ListResponse"));
+
+        foreach (var resource in resources.EnumerateArray())
+        {
+            Assert.True(resource.TryGetProperty("id", out var id));
+            Assert.That(id.GetString(), Is.AnyOf([SharedTestContext.Group1, SharedTestContext.Group2]));
+        }
+    }
+
+    [Test, Order(4)]
+    public async Task PostGroup3()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/group3.json");
+        var groupResponse = await Request.PostAsync("Groups",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.EqualTo(201));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        SharedTestContext.Group3 = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.Group3));
+        Assert.True(groupJson.Value.TryGetProperty("displayName", out var displayName));
+        Assert.That(displayName.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.False(string.IsNullOrWhiteSpace(displayName.GetString()));
+
+        Assert.True(groupJson.Value.TryGetProperty("members", out var members));
+        Assert.That(members.GetArrayLength(), Is.EqualTo(0));
+        Assert.True(groupJson.Value.TryGetProperty("schemas", out var schemas));
+        Assert.That(schemas.GetArrayLength(), Is.EqualTo(1));
+        Assert.That(schemas[0].ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(schemas[0].GetString(), Is.EqualTo("urn:ietf:params:scim:schemas:core:2.0:Group"));
+        Assert.True(groupJson.Value.TryGetProperty("externalId", out var externalId));
+        Assert.That(externalId.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.False(string.IsNullOrWhiteSpace(externalId.GetString()));
+        Assert.Pass($"Group 3 with ID '{SharedTestContext.Group3}' added!");
+    }
+
+    [Test, Order(5)]
+    public async Task PutGroup3()
+    {
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.Group3));
+        var data = await JsonLoader.LoadJsonDataAsync("./json/put_group3.json",["groupid3", "id3", "id4"] ,[SharedTestContext.Group3, SharedTestContext.User3, SharedTestContext.User4]);
+        var groupResponse = await Request.PutAsync($"Groups/{SharedTestContext.Group3}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.EqualTo(200));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(id.GetString(), Is.EqualTo(SharedTestContext.Group3));
+        Assert.True(groupJson.Value.TryGetProperty("displayName", out var displayName));
+        Assert.That(displayName.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.False(string.IsNullOrWhiteSpace(displayName.GetString()));
+        Assert.That(displayName.GetString(), Is.EqualTo("putName"));
+        Assert.False(groupJson.Value.TryGetProperty("externalId", out _));
+
+        Assert.True(groupJson.Value.TryGetProperty("members", out var members));
+        Assert.That(members.GetArrayLength(), Is.EqualTo(2));
+        foreach (var member in members.EnumerateArray())
+        {
+            Assert.True(member.TryGetProperty("value", out var value));
+            Assert.That(value.ValueKind, Is.EqualTo(JsonValueKind.String));
+            Assert.That(value.GetString(), Is.AnyOf([SharedTestContext.User3, SharedTestContext.User4]));
+        }
+        Assert.Pass($"Group 3 with ID '{SharedTestContext.Group3}' updated!");
+    }
+
+    [Test, Order(6)]
+    public async Task GetGroup3()
+    {
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.Group3));
+        var groupResponse = await Request.GetAsync($"Groups/{SharedTestContext.Group3}");
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.EqualTo(200));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(id.GetString(), Is.EqualTo(SharedTestContext.Group3));
+        Assert.True(groupJson.Value.TryGetProperty("displayName", out var displayName));
+        Assert.That(displayName.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.False(string.IsNullOrWhiteSpace(displayName.GetString()));
+        Assert.That(displayName.GetString(), Is.EqualTo("putName"), $"displayName should be 'putName', but received '{displayName.GetString()}'!");
+        Assert.False(groupJson.Value.TryGetProperty("externalId", out _));
+
+        Assert.True(groupJson.Value.TryGetProperty("members", out var members));
+        Assert.That(members.GetArrayLength(), Is.EqualTo(2));
+        foreach (var member in members.EnumerateArray())
+        {
+            Assert.True(member.TryGetProperty("value", out var value));
+            Assert.That(value.ValueKind, Is.EqualTo(JsonValueKind.String));
+            Assert.That(value.GetString(), Is.AnyOf([SharedTestContext.User3, SharedTestContext.User4]));
+        }
+        Assert.Pass($"Group 3 with ID '{SharedTestContext.Group3}' validated!");
+    }
+
+    [Test, Order(7)]
+    public async Task PatchAddUser4Group1()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/patch_add_user_group.json", "id", SharedTestContext.User4!);
+        var groupResponse = await Request.PatchAsync($"Groups/{SharedTestContext.Group1}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.AnyOf([200, 204]));
+    }
+
+    [Test, Order(8)]
+    public async Task PatchRemoveUser4Group1()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/patch_rm_user_group.json", "id", SharedTestContext.User4!);
+        var groupResponse = await Request.PatchAsync($"Groups/{SharedTestContext.Group1}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.AnyOf([200, 204]));
+    }
+
+    [Test, Order(9)]
+    public async Task PatchAddUser4Group1Again()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/patch_add_user_group.json", "id", SharedTestContext.User4!);
+        var groupResponse = await Request.PatchAsync($"Groups/{SharedTestContext.Group1}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.AnyOf([200, 204]));
+    }
+
+    [Test, Order(10)]
+    public async Task GetGroup1()
+    {
+        var groupResponse = await Request.GetAsync($"Groups/{SharedTestContext.Group1}");
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.EqualTo(200));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("members", out var members));
+        Assert.That(members.GetArrayLength(), Is.EqualTo(1));
+        Assert.True(members[0].TryGetProperty("value", out var value));
+        Assert.That(value.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(value.GetString(), Is.EqualTo(SharedTestContext.User4));
+    }
+
+    [Test, Order(11)]
+    public async Task PatchRemoveAllUsersGroup1()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/patch_rm_all_users_group.json");
+        var groupResponse = await Request.PatchAsync($"Groups/{SharedTestContext.Group1}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.AnyOf([200, 204]));
+    }
+
+    [Test, Order(12)]
+    public async Task GetNoUsersGroup1()
+    {
+        var groupResponse = await Request.GetAsync($"Groups/{SharedTestContext.Group1}");
+        Assert.True(groupResponse.Ok);
+        Assert.That(groupResponse.Status, Is.EqualTo(200));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("members", out var members));
+        Assert.That(members.GetArrayLength(), Is.EqualTo(0));
+    }
+
+    [SetUp]
+    public async Task SetUpApiTesting()
+    {
+        await CreateAPIRequestContext();
+        await GetAccessToken();
+    }
+
+    private async Task CreateAPIRequestContext()
+    {
+        // Assuming personal access token available in the environment.
+
+        Request = await this.Playwright.APIRequest.NewContextAsync(new()
+        {
+            // All requests we send go to this API endpoint.
+            BaseURL = _baseUrl,
+        });
+    }
+
+    private async Task GetAccessToken()
+    {
+        var headers = new Dictionary<string, string>();
+        var response = await Request.GetAsync("Token");
+        Assert.True(response.Ok);
+
+        var tokenJsonResponse = response.JsonAsync().Result;
+        if (!tokenJsonResponse.HasValue)
+        {
+            throw new Exception("No token found in response.");
+        }
+
+        if (tokenJsonResponse.Value.TryGetProperty("token", out var token) == true)
+        {
+            if (token.ValueKind == JsonValueKind.String)
+            {
+                // Add authorization token to all requests.
+                // Assuming personal access token available in the environment.
+                headers.Add("Authorization", $"Bearer {token}");
+                await Request.DisposeAsync();
+                Request = await this.Playwright.APIRequest.NewContextAsync(new()
+                {
+                    // All requests we send go to this API endpoint.
+                    BaseURL = _baseUrl,
+                    ExtraHTTPHeaders = headers
+                });
+            }
+        }
+    }
+
+    [Test]
+    public async Task DeleteUser3()
+    {
+        if (SharedTestContext.User3 == null)
+        {
+            Assert.Pass("User3 not found!");
+            return;
+        }
+        var userResponse = await Request.DeleteAsync($"Users/{SharedTestContext.User3}");
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+        SharedTestContext.User3 = null;
+
+    }
+
+    [Test]
+    public async Task DeleteUser4()
+    {
+        if (SharedTestContext.User4 == null)
+        {
+            Assert.Pass("User4 not found!");
+            return;
+        }
+        var userResponse = await Request.DeleteAsync($"Users/{SharedTestContext.User4}");
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+        SharedTestContext.User4 = null;
+    }
+
+    [Test]
+    public async Task DeleteGroup1()
+    {
+        if (SharedTestContext.Group1 == null)
+        {
+            Assert.Pass("Group1 not found!");
+            return;
+        }
+
+        var userResponse = await Request.DeleteAsync($"Groups/{SharedTestContext.Group1}");
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+        SharedTestContext.Group1 = null;
+    }
+
+    [Test]
+    public async Task DeleteGroup2()
+    {
+        if (SharedTestContext.Group2 == null)
+        {
+            Assert.Pass("Group2 not found!");
+            return;
+        }
+        var userResponse = await Request.DeleteAsync($"Groups/{SharedTestContext.Group2}");
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+        SharedTestContext.Group2 = null;
+    }
+    [Test]
+    public async Task DeleteGroup3()
+    {
+        if (SharedTestContext.Group3 == null)
+        {
+            Assert.Pass("Group3 not found!");
+            return;
+        }
+        var userResponse = await Request.DeleteAsync($"Groups/{SharedTestContext.Group3}");
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+        SharedTestContext.Group3 = null;
+    }
+
+
+    [TearDown]
+    public async Task TearDownAPITesting()
+    {
+        await Request.DisposeAsync();
+    }
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/Microsoft.SCIM.PlaywrightTests.csproj b/Microsoft.SCIM.PlaywrightTests/Microsoft.SCIM.PlaywrightTests.csproj
new file mode 100644
index 00000000..fd36e9f8
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/Microsoft.SCIM.PlaywrightTests.csproj
@@ -0,0 +1,40 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+    <RootNamespace>PlaywrightTests</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Microsoft.Playwright.NUnit" Version="1.44.0" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="3.9.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <Content Include="json\**">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="NUnit.Framework" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Microsoft.SystemForCrossDomainIdentityManagement\Microsoft.SCIM.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Microsoft.SystemForCrossDomainIdentityManagement\Microsoft.SCIM.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/Microsoft.SCIM.PlaywrightTests/UserAndGroupTestsWithGarbage.cs b/Microsoft.SCIM.PlaywrightTests/UserAndGroupTestsWithGarbage.cs
new file mode 100644
index 00000000..9f19bf65
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/UserAndGroupTestsWithGarbage.cs
@@ -0,0 +1,802 @@
+using System.Text.Json;
+using Microsoft.Playwright.NUnit;
+using Microsoft.Playwright;
+using PlaywrightTests.Utils;
+
+namespace PlaywrightTests;
+
+[TestFixture]
+public class UserAndGroupTestsWithGarbage : PlaywrightTest
+{
+    private IAPIRequestContext? Request;
+    static readonly string PROTOCOL = Environment.GetEnvironmentVariable("PROTOCOL") ?? "http";
+    static readonly string SERVER = Environment.GetEnvironmentVariable("SERVER") ?? "localhost";
+    static readonly string PORT = Environment.GetEnvironmentVariable("PORT") ?? ":5000";
+    static readonly string API = Environment.GetEnvironmentVariable("API") ?? "scim";
+    private static string _baseUrl = $"{PROTOCOL}://{SERVER}{PORT}/{API}/";
+
+    [Test, Order(1)]
+    public async Task PostUserOMalley()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user_omalley.json");
+        var userResponse = await Request!.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(201));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        SharedTestContext.UserOMalley = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.UserOMalley));
+        Assert.True(userJson.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("OMalley"));
+        Assert.True(userJson.Value.TryGetProperty("active", out var active));
+        Assert.That(active.GetBoolean(), Is.True);
+        Assert.Pass($"User OMalley with ID '{SharedTestContext.UserOMalley}' added!");
+    }
+
+    [Test, Order(1)]
+    public async Task PostUserEmp1WithStringActive()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user_emp1.json");
+        var userResponse = await Request!.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(201));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.True(userJson.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("emp1"));
+        Assert.True(userJson.Value.TryGetProperty("active", out var active));
+        Assert.That(active.GetBoolean(), Is.True);
+        SharedTestContext.UserEmp1 = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.UserEmp1));
+        Assert.Pass($"User with ID '{SharedTestContext.UserEmp1}' added!");
+    }
+
+    [Test, Order(2)]
+    public async Task GetUsers()
+    {
+        var userResponse = await Request!.GetAsync("Users");
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(200));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("totalResults", out var totalResults));
+        Assert.That(totalResults.GetInt32(), Is.EqualTo(2));
+        Assert.True(userJson.Value.TryGetProperty("Resources", out var resources));
+        Assert.That(resources.ValueKind, Is.EqualTo(JsonValueKind.Array));
+        Assert.That(resources.GetArrayLength(), Is.EqualTo(2));
+        foreach (var resource in resources.EnumerateArray())
+        {
+            Assert.True(resource.TryGetProperty("id", out var id));
+            Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+            var idValue = id.GetString();
+            Assert.That(idValue, Is.AnyOf([SharedTestContext.UserOMalley, SharedTestContext.UserEmp1]));
+        }
+    }
+
+    [Test, Order(3)]
+    public async Task PostUserEmp2()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user_emp2.json");
+        var userResponse = await Request!.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(201));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.True(userJson.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("emp2"));
+
+        SharedTestContext.UserEmp2 = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.UserEmp2));
+        Assert.Pass($"User Emp2 with ID '{SharedTestContext.UserEmp2}' added!");
+    }
+
+    [Test, Order(3)]
+    public async Task PostUserEmp3()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user_emp3.json");
+        var userResponse = await Request!.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(201));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.True(userJson.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("emp3"));
+
+        SharedTestContext.UserEmp3 = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.UserEmp3));
+        Assert.Pass($"User Emp3 with ID '{SharedTestContext.UserEmp3}' added!");
+    }
+
+    [Test, Order(3)]
+    public async Task PostUserNoName()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user_noname.json");
+        var userResponse = await Request!.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.False(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(400));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("detail", out var detail));
+        Assert.That(detail.GetString(),
+            Is.EqualTo("Request is unparsable, syntactically incorrect, or violates schema."));
+        Assert.True(userJson.Value.TryGetProperty("status", out var status));
+        Assert.That(status.GetInt32(), Is.EqualTo(400));
+    }
+
+    [Test, Order(3)]
+    public async Task PostUserJunk()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user_junk.json");
+        var userResponse = await Request!.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.False(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(400));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("detail", out var detail));
+        Assert.That(detail.GetString(),
+            Is.EqualTo("Request is unparsable, syntactically incorrect, or violates schema."));
+        Assert.True(userJson.Value.TryGetProperty("status", out var status));
+        Assert.That(status.GetInt32(), Is.EqualTo(400));
+    }
+
+    [Test, Order(3)]
+    public async Task PutOMalleyNoUserName()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/put_omalley_nouname.json", "1stuserid",
+            SharedTestContext.UserOMalley!);
+        var userResponse = await Request!.PutAsync($"Users/{SharedTestContext.UserOMalley}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.False(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(400));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("detail", out var detail));
+        Assert.That(detail.GetString(),
+            Is.EqualTo("Request is unparsable, syntactically incorrect, or violates schema."));
+        Assert.True(userJson.Value.TryGetProperty("status", out var status));
+        Assert.That(status.GetInt32(), Is.EqualTo(400));
+    }
+
+    [Test, Order(3)]
+    public async Task PutOMalleyTypo()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/put_omalley_typo.json", "1stuserid",
+            SharedTestContext.UserOMalley!);
+        var userResponse = await Request!.PutAsync($"Users/{SharedTestContext.UserOMalley}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(200));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.False(userJson!.Value.TryGetProperty("Addresses", out _));
+    }
+
+    [Test, Order(3)]
+    public async Task PostEnterpriseUser()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user_enterprise.json");
+        var userResponse = await Request!.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(201));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.True(userJson.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("enterprise"));
+        Assert.True(userJson.Value.TryGetProperty("active", out var active));
+        Assert.That(active.GetBoolean(), Is.True);
+        SharedTestContext.UserEnterprise = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.UserEnterprise));
+        Assert.Pass($"User Enterprise with ID '{SharedTestContext.UserEnterprise}' added!");
+    }
+
+    [Test, Order(4)]
+    public async Task PostUserEmp3Exists()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user_emp3.json");
+        var userResponse = await Request!.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.False(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(409));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("detail", out _));
+        Assert.True(userJson.Value.TryGetProperty("status", out var status));
+        Assert.That(status.GetInt32(), Is.EqualTo(409));
+    }
+
+    [Test, Order(4)]
+    public async Task PatchUserOMalleyUsername()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/patch_omalley_uname.json", "1stuserid",
+            SharedTestContext.UserOMalley!);
+        var patchResponse = await Request!.PatchAsync($"Users/{SharedTestContext.UserOMalley}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(patchResponse.Ok, await patchResponse.TextAsync());
+        Assert.That(patchResponse.Status, Is.AnyOf([200, 204]));
+    }
+
+    [Test, Order(4)]
+    public async Task PatchUserOMalleyActive()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/patch_omalley_active.json", "1stuserid",
+            SharedTestContext.UserOMalley!);
+        var patchResponse = await Request!.PatchAsync($"Users/{SharedTestContext.UserOMalley}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(patchResponse.Ok, await patchResponse.TextAsync());
+        Assert.That(patchResponse.Status, Is.AnyOf([200, 204]));
+    }
+
+    [Test, Order(5)]
+    public async Task CheckUserOMalleyPatch()
+    {
+        var userResponse = await Request!.GetAsync($"Users/{SharedTestContext.UserOMalley}");
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(200));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ToString(), Is.EqualTo(SharedTestContext.UserOMalley));
+        Assert.True(userJson.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("newusername"));
+        Assert.True(userJson.Value.TryGetProperty("active", out var active));
+        Assert.That(active.GetBoolean(), Is.False);
+    }
+
+    [Test, Order(6)]
+    public async Task PutUserOMalley()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/put_omalley.json", "1stuserid",
+            SharedTestContext.UserOMalley!);
+        var userResponse = await Request!.PutAsync($"Users/{SharedTestContext.UserOMalley}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(200));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("OMalley"));
+        Assert.True(userJson.Value.TryGetProperty("active", out var active));
+        Assert.That(active.GetBoolean(), Is.False);
+        Assert.True(userJson.Value.TryGetProperty("addresses", out var addresses));
+        Assert.That(addresses.GetArrayLength(), Is.EqualTo(2));
+        Assert.True(addresses[0].TryGetProperty("country", out var country));
+        Assert.That(country.GetString(), Is.EqualTo("Germany"));
+    }
+
+    [Test, Order(6)]
+    public async Task GetUsersPaginate()
+    {
+        var usersResponse = await Request!.GetAsync("Users?startIndex=1&count=2");
+        Assert.True(usersResponse.Ok, await usersResponse.TextAsync());
+        Assert.That(usersResponse.Status, Is.EqualTo(200));
+
+        var usersJson = await usersResponse.JsonAsync();
+        Assert.True(usersJson.HasValue);
+        Assert.True(usersJson!.Value.TryGetProperty("totalResults", out var totalResults));
+        Assert.That(totalResults.GetInt32(), Is.EqualTo(5));
+        Assert.True(usersJson.Value.TryGetProperty("itemsPerPage", out var itemsPerPage));
+        Assert.That(itemsPerPage.GetInt32(), Is.EqualTo(2));
+        Assert.True(usersJson.Value.TryGetProperty("startIndex", out var startIndex));
+        Assert.That(startIndex.GetInt32(), Is.EqualTo(1));
+        Assert.True(usersJson.Value.TryGetProperty("Resources", out var resources));
+        Assert.That(resources.ValueKind, Is.EqualTo(JsonValueKind.Array));
+        Assert.That(resources.GetArrayLength(), Is.EqualTo(2));
+        foreach (var resource in resources.EnumerateArray())
+        {
+            Assert.True(resource.TryGetProperty("id", out var id));
+            Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+            var idValue = id.GetString();
+            Assert.That(idValue,
+                Is.AnyOf([
+                    SharedTestContext.UserOMalley, SharedTestContext.UserEmp1, SharedTestContext.UserEmp2,
+                    SharedTestContext.UserEmp3, SharedTestContext.UserEnterprise
+                ]));
+        }
+    }
+
+    [Test, Order(6)]
+    public async Task GetUsersAttributes()
+    {
+        var usersResponse = await Request!.GetAsync("Users?attributes=userName,emails");
+        Assert.True(usersResponse.Ok, await usersResponse.TextAsync());
+        Assert.That(usersResponse.Status, Is.EqualTo(200));
+
+        var usersJson = await usersResponse.JsonAsync();
+        Assert.True(usersJson.HasValue);
+        Assert.True(usersJson!.Value.TryGetProperty("totalResults", out var totalResults));
+        Assert.That(totalResults.GetInt32(), Is.EqualTo(5));
+        Assert.True(usersJson.Value.TryGetProperty("Resources", out var resources));
+        Assert.That(resources.ValueKind, Is.EqualTo(JsonValueKind.Array));
+        Assert.That(resources.GetArrayLength(), Is.EqualTo(5));
+        foreach (var resource in resources.EnumerateArray())
+        {
+            Assert.True(resource.TryGetProperty("id", out var id));
+            Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+            var idValue = id.GetString();
+            Assert.That(idValue,
+                Is.AnyOf([
+                    SharedTestContext.UserOMalley, SharedTestContext.UserEmp1, SharedTestContext.UserEmp2,
+                    SharedTestContext.UserEmp3, SharedTestContext.UserEnterprise
+                ]));
+        }
+    }
+
+    [Test, Order(6)]
+    public async Task PostUserEmp3Again()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user_emp3.json");
+        var userResponse = await Request!.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.False(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(409));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("detail", out _));
+        Assert.True(userJson.Value.TryGetProperty("status", out var status));
+        Assert.That(status.GetInt32(), Is.EqualTo(409));
+    }
+
+    [Test, Order(6)]
+    public async Task FilterEqAndValue()
+    {
+        var usersResponse =
+            await Request!.GetAsync(
+                "Users?filter=name.FamilyName eq Employee and (emails.Value co example.com or emails.Value co example.org)");
+        Assert.That(usersResponse.Status, Is.AnyOf([200, 400]));
+
+        var usersJson = await usersResponse.JsonAsync();
+        Assert.True(usersJson.HasValue);
+        if (usersResponse.Status == 200)
+        {
+            Assert.True(usersJson!.Value.TryGetProperty("totalResults", out var totalResults));
+            Assert.That(totalResults.GetInt32(), Is.EqualTo(4));
+            Assert.True(usersJson.Value.TryGetProperty("Resources", out var resources));
+            Assert.That(resources.ValueKind, Is.EqualTo(JsonValueKind.Array));
+            Assert.That(resources.GetArrayLength(), Is.EqualTo(4));
+            foreach (var resource in resources.EnumerateArray())
+            {
+                Assert.True(resource.TryGetProperty("id", out var id));
+                Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+                var idValue = id.GetString();
+                Assert.That(idValue,
+                    Is.AnyOf([
+                        SharedTestContext.UserEmp1, SharedTestContext.UserEmp2, SharedTestContext.UserEmp3,
+                        SharedTestContext.UserEnterprise
+                    ]));
+            }
+        }
+        else
+        {
+            Assert.True(usersJson!.Value.TryGetProperty("status", out var status));
+            Assert.That(status.GetInt32(), Is.EqualTo(400));
+            Assert.True(usersJson.Value.TryGetProperty("scimType", out var scimType));
+            Assert.That(scimType.GetString(), Is.EqualTo("invalidFilter"));
+            Assert.True(usersJson.Value.TryGetProperty("detail", out var detail));
+            Assert.That(detail.GetString(),
+                Does.StartWith("This filter operator is not supported").Or
+                    .StartWith("Filtering by this attribute is not supported"), detail.GetString());
+            Assert.Warn($"WARNING: {detail.GetString()}");
+        }
+    }
+
+    [Test, Order(6)]
+    public async Task FilterStartsWith()
+    {
+        var usersResponse = await Request!.GetAsync("Users?filter=userName sw O");
+        Assert.That(usersResponse.Status, Is.AnyOf([200, 400]));
+
+        var usersJson = await usersResponse.JsonAsync();
+        Assert.True(usersJson.HasValue);
+        if (usersResponse.Status == 200)
+        {
+            Assert.True(usersJson!.Value.TryGetProperty("totalResults", out var totalResults));
+            Assert.That(totalResults.GetInt32(), Is.EqualTo(1));
+            Assert.True(usersJson.Value.TryGetProperty("Resources", out var resources));
+            Assert.That(resources.ValueKind, Is.EqualTo(JsonValueKind.Array));
+            Assert.That(resources.GetArrayLength(), Is.EqualTo(1));
+            foreach (var resource in resources.EnumerateArray())
+            {
+                Assert.True(resource.TryGetProperty("id", out var id));
+                Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+                var idValue = id.GetString();
+                Assert.That(idValue, Is.EqualTo(SharedTestContext.UserOMalley));
+            }
+        }
+        else
+        {
+            Assert.True(usersJson!.Value.TryGetProperty("status", out var status));
+            Assert.That(status.GetInt32(), Is.EqualTo(400));
+            Assert.True(usersJson.Value.TryGetProperty("scimType", out var scimType));
+            Assert.That(scimType.GetString(), Is.EqualTo("invalidFilter"));
+            Assert.True(usersJson.Value.TryGetProperty("detail", out var detail));
+            Assert.That(detail.GetString(),
+                Does.StartWith("This filter operator is not supported").Or
+                    .StartWith("Filtering by this attribute is not supported"), detail.GetString());
+            Assert.Warn($"WARNING: {detail.GetString()}");
+        }
+    }
+
+    [Test, Order(6)]
+    public async Task FilterGreaterThan()
+    {
+        var usersResponse = await Request!.GetAsync("Users?filter=meta.Created gt 2015-10-10T14:38:21.8617979-07:00");
+        Assert.That(usersResponse.Status, Is.AnyOf([200, 400]));
+
+        var usersJson = await usersResponse.JsonAsync();
+        Assert.True(usersJson.HasValue);
+        if (usersResponse.Status == 200)
+        {
+            Assert.True(usersJson!.Value.TryGetProperty("totalResults", out var totalResults));
+            Assert.That(totalResults.GetInt32(), Is.EqualTo(5));
+            Assert.True(usersJson.Value.TryGetProperty("Resources", out var resources));
+            Assert.That(resources.ValueKind, Is.EqualTo(JsonValueKind.Array));
+            Assert.That(resources.GetArrayLength(), Is.EqualTo(5));
+            foreach (var resource in resources.EnumerateArray())
+            {
+                Assert.True(resource.TryGetProperty("id", out var id));
+                Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+                var idValue = id.GetString();
+                Assert.That(idValue,
+                    Is.AnyOf([
+                        SharedTestContext.UserOMalley, SharedTestContext.UserEmp1, SharedTestContext.UserEmp2,
+                        SharedTestContext.UserEmp3, SharedTestContext.UserEnterprise
+                    ]));
+            }
+        }
+        else
+        {
+            Assert.True(usersJson!.Value.TryGetProperty("status", out var status));
+            Assert.That(status.GetInt32(), Is.EqualTo(400));
+            Assert.True(usersJson.Value.TryGetProperty("scimType", out var scimType));
+            Assert.That(scimType.GetString(), Is.EqualTo("invalidFilter"));
+            Assert.True(usersJson.Value.TryGetProperty("detail", out var detail));
+            Assert.That(detail.GetString(),
+                Does.StartWith("This filter operator is not supported").Or
+                    .StartWith("Filtering by this attribute is not supported"), detail.GetString());
+            Assert.Warn($"WARNING: {detail.GetString()}");
+        }
+    }
+
+    // Group tests
+
+    [Test, Order(3)]
+    public async Task PostGroup()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/group1garbage.json");
+        var groupResponse = await Request!.PostAsync("Groups",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(groupResponse.Ok, await groupResponse.TextAsync());
+        Assert.That(groupResponse.Status, Is.EqualTo(201));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        SharedTestContext.Group1Garbage = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.Group1Garbage));
+        Assert.Pass($"Group1Garbage with ID '{SharedTestContext.Group1Garbage}' added!");
+    }
+
+    [Test, Order(4)]
+    public async Task PatchGroupAddJunkUsers()
+    {
+        var data1 = await JsonLoader.LoadJsonDataAsync("./json/patch_add_junk_user_group.json",
+            ["1stgroupid", "junkuserid"], [SharedTestContext.Group1Garbage!, "string id 1"]);
+        var patch1Response = await Request!.PatchAsync($"Groups/{SharedTestContext.Group1Garbage}",
+            new()
+            {
+                DataString = data1,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(patch1Response.Ok, await patch1Response.TextAsync());
+        Assert.That(patch1Response.Status, Is.AnyOf([200, 204]));
+
+        var data2 = await JsonLoader.LoadJsonDataAsync("./json/patch_add_junk_user_group.json",
+            ["1stgroupid", "junkuserid"], [SharedTestContext.Group1Garbage!, "string id 2"]);
+        var patch2Response = await Request!.PatchAsync($"Groups/{SharedTestContext.Group1Garbage}",
+            new()
+            {
+                DataString = data2,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(patch2Response.Ok, await patch2Response.TextAsync());
+        Assert.That(patch2Response.Status, Is.AnyOf([200, 204]));
+    }
+
+    [Test, Order(5)]
+    public async Task GetGroup()
+    {
+        var groupResponse = await Request!.GetAsync($"Groups/{SharedTestContext.Group1Garbage}");
+        Assert.True(groupResponse.Ok, await groupResponse.TextAsync());
+        Assert.That(groupResponse.Status, Is.EqualTo(200));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.True(groupJson.Value.TryGetProperty("displayName", out var displayName));
+        Assert.That(displayName.GetString(), Is.EqualTo("Group 1"));
+        Assert.True(groupJson.Value.TryGetProperty("members", out var members));
+        Assert.That(members.GetArrayLength(), Is.EqualTo(2));
+        Assert.True(members[0].TryGetProperty("value", out var value1));
+        Assert.That(value1.GetString(), Is.EqualTo("string id 1"));
+        Assert.True(members[1].TryGetProperty("value", out var value2));
+        Assert.That(value2.GetString(), Is.EqualTo("string id 2"));
+    }
+
+    [Test, Order(5)]
+    public async Task GetGroupExcludeMembers()
+    {
+        var groupResponse =
+            await Request!.GetAsync($"Groups/{SharedTestContext.Group1Garbage}?excludedAttributes=members");
+        Assert.True(groupResponse.Ok, await groupResponse.TextAsync());
+        Assert.That(groupResponse.Status, Is.EqualTo(200));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.True(groupJson.Value.TryGetProperty("displayName", out var displayName));
+        Assert.That(displayName.GetString(), Is.EqualTo("Group 1"));
+
+        if (groupJson.Value.TryGetProperty("members", out _))
+        {
+            Assert.Warn("WARNING: Members should be excluded!");
+        }
+    }
+
+    [Test, Order(6)]
+    public async Task PutGroup()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/put_group1garbage.json", "1stgroupid",
+            SharedTestContext.Group1Garbage!);
+        var groupResponse = await Request!.PutAsync($"Groups/{SharedTestContext.Group1Garbage}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(groupResponse.Ok, await groupResponse.TextAsync());
+        Assert.That(groupResponse.Status, Is.EqualTo(200));
+
+        var groupJson = await groupResponse.JsonAsync();
+        Assert.True(groupJson.HasValue);
+        Assert.True(groupJson!.Value.TryGetProperty("displayName", out var displayName));
+        Assert.That(displayName.GetString(), Is.EqualTo("Tiffany Ortiz"));
+    }
+
+    [SetUp]
+    public async Task SetUpApiTesting()
+    {
+        await CreateApiRequestContext();
+        await GetAccessToken();
+    }
+
+    private async Task CreateApiRequestContext()
+    {
+        // Assuming personal access token available in the environment.
+
+        Request = await this.Playwright.APIRequest.NewContextAsync(new()
+        {
+            // All requests we send go to this API endpoint.
+            BaseURL = _baseUrl,
+        });
+    }
+
+    private async Task GetAccessToken()
+    {
+        var headers = new Dictionary<string, string>();
+        var response = await Request!.GetAsync("Token");
+        Assert.True(response.Ok, await response.TextAsync());
+
+        var tokenJsonResponse = response.JsonAsync().Result;
+        if (!tokenJsonResponse.HasValue)
+        {
+            throw new Exception("No token found in response.");
+        }
+
+        if (tokenJsonResponse.Value.TryGetProperty("token", out var token))
+        {
+            if (token.ValueKind == JsonValueKind.String)
+            {
+                // Add authorization token to all requests.
+                // Assuming personal access token available in the environment.
+                headers.Add("Authorization", $"Bearer {token}");
+                await Request!.DisposeAsync();
+                Request = await this.Playwright.APIRequest.NewContextAsync(new()
+                {
+                    // All requests we send go to this API endpoint.
+                    BaseURL = _baseUrl,
+                    ExtraHTTPHeaders = headers
+                });
+            }
+        }
+    }
+
+    [Test]
+    public async Task DeleteUserOMalley()
+    {
+        if (SharedTestContext.UserOMalley == null)
+        {
+            Assert.Warn("UserOMalley not found!");
+            return;
+        }
+
+        var userResponse = await Request!.DeleteAsync($"Users/{SharedTestContext.UserOMalley}");
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+        SharedTestContext.UserOMalley = null;
+    }
+
+    [Test]
+    public async Task DeleteUserEmp1()
+    {
+        if (SharedTestContext.UserEmp1 == null)
+        {
+            Assert.Warn("UserEmp1 not found!");
+            return;
+        }
+
+        var userResponse = await Request!.DeleteAsync($"Users/{SharedTestContext.UserEmp1}");
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+        SharedTestContext.UserEmp1 = null;
+    }
+
+    [Test]
+    public async Task DeleteUserEmp2()
+    {
+        if (SharedTestContext.UserEmp2 == null)
+        {
+            Assert.Warn("UserEmp2 not found!");
+            return;
+        }
+
+        var userResponse = await Request!.DeleteAsync($"Users/{SharedTestContext.UserEmp2}");
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+        SharedTestContext.UserEmp2 = null;
+    }
+
+    [Test]
+    public async Task DeleteUserEmp3()
+    {
+        if (SharedTestContext.UserEmp3 == null)
+        {
+            Assert.Warn("UserEmp3 not found!");
+            return;
+        }
+
+        var userResponse = await Request!.DeleteAsync($"Users/{SharedTestContext.UserEmp3}");
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+        SharedTestContext.UserEmp3 = null;
+    }
+
+    [Test]
+    public async Task DeleteUserEnterprise()
+    {
+        if (SharedTestContext.UserEnterprise == null)
+        {
+            Assert.Warn("UserEnterprise not found!");
+            return;
+        }
+
+        var userResponse = await Request!.DeleteAsync($"Users/{SharedTestContext.UserEnterprise}");
+        Assert.True(userResponse.Ok, await userResponse.TextAsync());
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+        SharedTestContext.UserEnterprise = null;
+    }
+
+    [Test]
+    public async Task DeleteGroup1Garbage()
+    {
+        if (SharedTestContext.Group1Garbage == null)
+        {
+            Assert.Warn("Group1Garbage not found!");
+            return;
+        }
+
+        var groupResponse = await Request!.DeleteAsync($"Groups/{SharedTestContext.Group1Garbage}");
+        Assert.True(groupResponse.Ok, await groupResponse.TextAsync());
+        Assert.That(groupResponse.Status, Is.EqualTo(204));
+        SharedTestContext.Group1Garbage = null;
+    }
+
+    [TearDown]
+    public async Task TearDownApiTesting()
+    {
+        await Request!.DisposeAsync();
+    }
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/UserTests.cs b/Microsoft.SCIM.PlaywrightTests/UserTests.cs
new file mode 100644
index 00000000..8506645d
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/UserTests.cs
@@ -0,0 +1,278 @@
+using System.Text.Json;
+using Microsoft.Playwright.NUnit;
+using Microsoft.Playwright;
+using PlaywrightTests.Utils;
+
+namespace PlaywrightTests;
+
+[TestFixture]
+public class UserTests : PlaywrightTest
+{
+    private IAPIRequestContext? Request;
+    static string PROTOCOL = Environment.GetEnvironmentVariable("PROTOCOL") ?? "http";
+    static string SERVER = Environment.GetEnvironmentVariable("SERVER") ?? "localhost";
+    static string PORT = Environment.GetEnvironmentVariable("PORT") ?? ":5000";
+    static string API = Environment.GetEnvironmentVariable("API") ?? "scim";
+    private static string _baseUrl = $"{PROTOCOL}://{SERVER}{PORT}/{API}/";
+
+    [Test, Order(1)]
+    public async Task PostUser()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user1.json");
+        var userResponse = await Request.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(201));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        SharedTestContext.User1 = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.User1));
+        Assert.Pass($"User with ID '{SharedTestContext.User1}' added!");
+    }
+
+    [Test, Order(1)]
+    public async Task PostEnterpriseUser()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/user2.json");
+        var userResponse = await Request.PostAsync("Users",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(201));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        SharedTestContext.User2 = id.GetString();
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.User2));
+        Assert.Pass($"User with ID '{SharedTestContext.User2}' added!");
+    }
+
+    [Test, Order(2)]
+    public async Task GetUser1()
+    {
+        var userResponse = await Request.GetAsync($"Users/{SharedTestContext.User1}");
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(200));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(id.ToString(), Is.EqualTo(SharedTestContext.User1));
+    }
+
+    [Test, Order(2)]
+    public async Task GetUser2()
+    {
+        var userResponse = await Request.GetAsync($"Users/{SharedTestContext.User2}");
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(200));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+        Assert.That(id.ToString(), Is.EqualTo(SharedTestContext.User2));
+    }
+
+    [Test, Order(2)]
+    public async Task GetUserAttributes()
+    {
+        var usersResponse = await Request.GetAsync("Users?attributes=userName,emails");
+        Assert.True(usersResponse.Ok);
+        Assert.That(usersResponse.Status, Is.EqualTo(200));
+
+        var usersJson = await usersResponse.JsonAsync();
+        Assert.True(usersJson.HasValue);
+        Assert.True(usersJson.Value.TryGetProperty("totalResults", out var totalResults));
+        Assert.That(totalResults.GetInt32(), Is.EqualTo(2));
+        Assert.True(usersJson.Value.TryGetProperty("Resources", out var resources));
+        Assert.That(resources.ValueKind, Is.EqualTo(JsonValueKind.Array));
+        Assert.That(resources.GetArrayLength(), Is.EqualTo(2));
+        foreach (var resource in resources.EnumerateArray())
+        {
+            Assert.True(resource.TryGetProperty("id", out var id));
+            Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+            var idValue = id.GetString();
+            Assert.That(idValue, Is.AnyOf([SharedTestContext.User1, SharedTestContext.User2]));
+        }
+    }
+
+    [Test, Order(2)]
+    public async Task GetUserFilters()
+    {
+        var usersResponse = await Request.GetAsync("Users/?filter=DisplayName+eq+%22BobIsAmazing%22");
+        Assert.True(usersResponse.Ok);
+        Assert.That(usersResponse.Status, Is.EqualTo(200));
+
+        var usersJson = await usersResponse.JsonAsync();
+        Assert.True(usersJson.HasValue);
+        Assert.True(usersJson.Value.TryGetProperty("totalResults", out var totalResults));
+        Assert.That(totalResults.GetInt32(), Is.EqualTo(1));
+        Assert.True(usersJson.Value.TryGetProperty("Resources", out var resources));
+        Assert.That(resources.ValueKind, Is.EqualTo(JsonValueKind.Array));
+        Assert.That(resources.GetArrayLength(), Is.EqualTo(1));
+        foreach (var resource in resources.EnumerateArray())
+        {
+            Assert.True(resource.TryGetProperty("id", out var id));
+            Assert.That(id.ValueKind, Is.EqualTo(JsonValueKind.String));
+            var idValue = id.GetString();
+            Assert.That(idValue, Is.EqualTo(SharedTestContext.User1));
+        }
+    }
+
+    [Test, Order(3)]
+    public async Task PatchUser1()
+    {
+        var data = await JsonLoader.LoadJsonDataAsync("./json/patch_user1.json");
+        var patchResponse = await Request.PatchAsync($"Users/{SharedTestContext.User1}", new()
+        {
+            DataString = data,
+            Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+        });
+        Assert.True(patchResponse.Ok);
+        Assert.That(patchResponse.Status, Is.EqualTo(200));
+
+        var userJson = await patchResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ToString(), Is.EqualTo(SharedTestContext.User1));
+        Assert.True(userJson.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("ryan3"));
+    }
+
+    [Test, Order(4)]
+    public async Task CheckUser1Patch()
+    {
+        var patchResponse = await Request.GetAsync($"Users/{SharedTestContext.User1}");
+        Assert.True(patchResponse.Ok);
+        Assert.That(patchResponse.Status, Is.EqualTo(200));
+
+        var userJson = await patchResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ToString(), Is.EqualTo(SharedTestContext.User1));
+        Assert.True(userJson.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("ryan3"));
+    }
+
+    [Test, Order(4)]
+    public async Task PutUser2()
+    {
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.User2));
+        var data = await JsonLoader.LoadJsonDataAsync("./json/put_user2.json", "id2", SharedTestContext.User2!);
+        var putResponse = await Request.PutAsync($"Users/{SharedTestContext.User2}",
+            new()
+            {
+                DataString = data,
+                Headers = new KeyValuePair<string, string>[] { new("Content-Type", "application/json") }
+            });
+        Assert.True(putResponse.Ok);
+        Assert.That(putResponse.Status, Is.EqualTo(200));
+
+        var userJson = await putResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ToString(), Is.EqualTo(SharedTestContext.User2));
+        Assert.True(userJson.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("UserNameReplace2"));
+    }
+
+    [Test, Order(5)]
+    public async Task CheckUser2Put()
+    {
+        Assert.False(string.IsNullOrWhiteSpace(SharedTestContext.User2));
+        var userResponse = await Request.GetAsync($"Users/{SharedTestContext.User2}");
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(200));
+
+        var userJson = await userResponse.JsonAsync();
+        Assert.True(userJson.HasValue);
+        Assert.True(userJson!.Value.TryGetProperty("id", out var id));
+        Assert.That(id.ToString(), Is.EqualTo(SharedTestContext.User2));
+        Assert.True(userJson.Value.TryGetProperty("userName", out var userName));
+        Assert.That(userName.GetString(), Is.EqualTo("UserNameReplace2"));
+    }
+
+    [SetUp]
+    public async Task SetUpApiTesting()
+    {
+        await CreateApiRequestContext();
+        await GetAccessToken();
+    }
+
+    private async Task CreateApiRequestContext()
+    {
+        // Assuming personal access token available in the environment.
+
+        Request = await this.Playwright.APIRequest.NewContextAsync(new()
+        {
+            // All requests we send go to this API endpoint.
+            BaseURL = _baseUrl,
+        });
+    }
+
+    private async Task GetAccessToken()
+    {
+        var headers = new Dictionary<string, string>();
+        var response = await Request.GetAsync("Token");
+        Assert.True(response.Ok);
+
+        var tokenJsonResponse = response.JsonAsync().Result;
+        if (!tokenJsonResponse.HasValue)
+        {
+            throw new Exception("No token found in response.");
+        }
+
+        if (tokenJsonResponse.Value.TryGetProperty("token", out var token) == true)
+        {
+            if (token.ValueKind == JsonValueKind.String)
+            {
+                // Add authorization token to all requests.
+                // Assuming personal access token available in the environment.
+                headers.Add("Authorization", $"Bearer {token}");
+                await Request.DisposeAsync();
+                Request = await this.Playwright.APIRequest.NewContextAsync(new()
+                {
+                    // All requests we send go to this API endpoint.
+                    BaseURL = _baseUrl,
+                    ExtraHTTPHeaders = headers
+                });
+            }
+        }
+    }
+
+    [Test]
+    public async Task DeleteUser1()
+    {
+        var userResponse = await Request.DeleteAsync($"Users/{SharedTestContext.User1}");
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+    }
+
+    [Test]
+    public async Task DeleteUser2()
+    {
+        var userResponse = await Request.DeleteAsync($"Users/{SharedTestContext.User2}");
+        Assert.True(userResponse.Ok);
+        Assert.That(userResponse.Status, Is.EqualTo(204));
+    }
+
+    [TearDown]
+    public async Task TearDownAPITesting()
+    {
+        await Request.DisposeAsync();
+    }
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/Utils/JsonLoader.cs b/Microsoft.SCIM.PlaywrightTests/Utils/JsonLoader.cs
new file mode 100644
index 00000000..d1ab29f6
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/Utils/JsonLoader.cs
@@ -0,0 +1,41 @@
+namespace PlaywrightTests.Utils;
+
+public class JsonLoader
+{
+    public static async Task<string> LoadJsonDataAsync(string filePath, string variable, string value)
+    {
+        // Read the content of the JSON file
+        string jsonContent = await File.ReadAllTextAsync(filePath);
+
+        // Replace the placeholder with the actual value
+        jsonContent = jsonContent.Replace("{{" + variable + "}}", value);
+
+        // Parse the JSON content into a dynamic object
+        return jsonContent;
+    }
+
+    public static async Task<string> LoadJsonDataAsync(string filePath, string[] variables, string[] values)
+    {
+        if (variables.Length != values.Length)
+        {
+            throw new ArgumentException("The number of variables and values must be the same.");
+        }
+
+        // Read the content of the JSON file
+        string jsonContent = await File.ReadAllTextAsync(filePath);
+        // Replace the placeholder with the actual value
+        for (int i = 0; i < variables.Length; i++)
+        {
+            jsonContent = jsonContent.Replace("{{" + variables[i] + "}}", values[i]);
+        }
+
+        // Parse the JSON content into a dynamic object
+        return jsonContent;
+    }
+
+    public static async Task<string> LoadJsonDataAsync(string filePath)
+    {
+        // Read the content of the JSON file
+        return await File.ReadAllTextAsync(filePath);
+    }
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/Utils/SharedTestContext.cs b/Microsoft.SCIM.PlaywrightTests/Utils/SharedTestContext.cs
new file mode 100644
index 00000000..e2b80bc5
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/Utils/SharedTestContext.cs
@@ -0,0 +1,17 @@
+namespace PlaywrightTests.Utils;
+public static class SharedTestContext
+{
+    public static string? User1 { get; set; }
+    public static string? User2 { get; set; }
+    public static string? User3 { get; set; }
+    public static string? User4 { get; set; }
+    public static string? UserOMalley { get; set; }
+    public static string? UserEmp1 { get; set; }
+    public static string? UserEmp2 { get; set; }
+    public static string? UserEmp3 { get; set; }
+    public static string? UserEnterprise { get; set; }
+    public static string? Group1 { get; set; }
+    public static string? Group2 { get; set; }
+    public static string? Group3 { get; set; }
+    public static string? Group1Garbage { get; set; }
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/group1.json b/Microsoft.SCIM.PlaywrightTests/json/group1.json
new file mode 100644
index 00000000..dd016574
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/group1.json
@@ -0,0 +1,6 @@
+{
+  "externalId":"${__UUID}",
+  "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"],
+  "displayName": "Group1DisplayName",
+  "members":[]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/group1garbage.json b/Microsoft.SCIM.PlaywrightTests/json/group1garbage.json
new file mode 100644
index 00000000..798fd659
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/group1garbage.json
@@ -0,0 +1,7 @@
+{
+  "displayName": "Group 1",
+  "externalId": "015489ea-9410-4306-b583-9f002b2446f7",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:Group"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/group2.json b/Microsoft.SCIM.PlaywrightTests/json/group2.json
new file mode 100644
index 00000000..eccd5a05
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/group2.json
@@ -0,0 +1,12 @@
+{
+  "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"],
+  "externalId":"${__UUID}",
+  "displayName": "GroupDisplayName2",
+  "members":
+  [
+    {
+      "value":"{{id3}}",
+      "display":"VP"
+    }
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/group3.json b/Microsoft.SCIM.PlaywrightTests/json/group3.json
new file mode 100644
index 00000000..be7d24c2
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/group3.json
@@ -0,0 +1,6 @@
+{
+  "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"],
+  "externalId":"${__UUID}",
+  "displayName": "GroupDisplayName3",
+  "members":[]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/patch_add_junk_user_group.json b/Microsoft.SCIM.PlaywrightTests/json/patch_add_junk_user_group.json
new file mode 100644
index 00000000..c2a268eb
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/patch_add_junk_user_group.json
@@ -0,0 +1,13 @@
+{
+  "id": "{{1stgroupid}}",
+  "Operations": [
+    {
+      "op":"add",
+      "path": "members",
+      "value": "{{junkuserid}}"
+    }
+  ],
+  "schemas": [
+    "urn:ietf:params:scim:api:messages:2.0:PatchOp"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/patch_add_user_group.json b/Microsoft.SCIM.PlaywrightTests/json/patch_add_user_group.json
new file mode 100644
index 00000000..0d126bfe
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/patch_add_user_group.json
@@ -0,0 +1,19 @@
+{
+  "schemas": [
+    "urn:ietf:params:scim:api:messages:2.0:PatchOp"
+  ],
+  "Operations": [
+    {
+      "name": "addMember",
+      "op": "add",
+      "path": "members",
+      "value": [
+        {
+          "displayName":"{{displayName}}",
+          "value":"{{id}}"
+        }
+      ]
+
+    }
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/patch_omalley_active.json b/Microsoft.SCIM.PlaywrightTests/json/patch_omalley_active.json
new file mode 100644
index 00000000..da36bcdd
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/patch_omalley_active.json
@@ -0,0 +1,9 @@
+{
+  "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
+  "Operations":[
+    {
+      "op":"Replace",
+      "path":"active",
+      "value": false
+    }]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/patch_omalley_uname.json b/Microsoft.SCIM.PlaywrightTests/json/patch_omalley_uname.json
new file mode 100644
index 00000000..f6f9e833
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/patch_omalley_uname.json
@@ -0,0 +1,9 @@
+{
+  "schemas": ["urn:ietf:params:scim:api:messages:2.0:PatchOp"],
+  "Operations":[
+    {
+      "op":"Replace",
+      "path":"userName",
+      "value":"newusername"
+    }]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/patch_rm_all_users_group.json b/Microsoft.SCIM.PlaywrightTests/json/patch_rm_all_users_group.json
new file mode 100644
index 00000000..7c9244c9
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/patch_rm_all_users_group.json
@@ -0,0 +1,11 @@
+{
+  "schemas": [
+    "urn:ietf:params:scim:api:messages:2.0:PatchOp"
+  ],
+  "Operations": [
+    {
+      "op": "remove",
+      "path": "members"
+    }
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/patch_rm_user_group.json b/Microsoft.SCIM.PlaywrightTests/json/patch_rm_user_group.json
new file mode 100644
index 00000000..2cdd3b4f
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/patch_rm_user_group.json
@@ -0,0 +1,11 @@
+{
+  "schemas": [
+    "urn:ietf:params:scim:api:messages:2.0:PatchOp"
+  ],
+  "Operations": [
+    {
+      "op": "remove",
+      "path": "members[value eq \"{{id}}\"]"
+    }
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/patch_user1.json b/Microsoft.SCIM.PlaywrightTests/json/patch_user1.json
new file mode 100644
index 00000000..b582410c
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/patch_user1.json
@@ -0,0 +1,12 @@
+{
+  "schemas": [
+    "urn:ietf:params:scim:api:messages:2.0:PatchOp"
+  ],
+  "Operations": [
+    {
+      "op": "replace",
+      "path": "userName",
+      "value": "ryan3"
+    }
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/put_group1garbage.json b/Microsoft.SCIM.PlaywrightTests/json/put_group1garbage.json
new file mode 100644
index 00000000..3e923416
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/put_group1garbage.json
@@ -0,0 +1,8 @@
+{
+  "id": "{{1stgroupid}}",
+  "displayName": "Tiffany Ortiz",
+  "externalId": "6c6b54c2-fa81-4234-ad4f-420ec6808049",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:Group"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/put_group3.json b/Microsoft.SCIM.PlaywrightTests/json/put_group3.json
new file mode 100644
index 00000000..98580915
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/put_group3.json
@@ -0,0 +1,15 @@
+{
+  "schemas": ["urn:ietf:params:scim:schemas:core:2.0:Group"],
+  "id":"{{groupid3}}",
+  "displayName": "putName",
+  "members":[
+    {
+      "value": "{{id3}}",
+      "display":"VP"
+    },
+    {
+      "value":"{{id4}}",
+      "display":"SenorVP"
+    }
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/put_omalley.json b/Microsoft.SCIM.PlaywrightTests/json/put_omalley.json
new file mode 100644
index 00000000..8e00b2c4
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/put_omalley.json
@@ -0,0 +1,76 @@
+{
+  "id" : "{{1stuserid}}",
+  "userName": "OMalley",
+  "active": false,
+  "addresses": [
+    {
+      "country": "Germany",
+      "formatted": "1923 Jennifer Way Suite 040\nSouth Nancy, MI 55645",
+      "locality": "East Mercedes",
+      "postalCode": "99265",
+      "region": "Montana",
+      "streetAddress": "4939 Hess Fork",
+      "type": "work",
+      "primary": false
+    },
+    {
+      "country": "bahams",
+      "formatted": "18522 Lisa Unions\nEast Gregory, CT 52311",
+      "locality": null,
+      "postalCode": null,
+      "region": null,
+      "streetAddress": null,
+      "type": "other",
+      "primary": false
+    }
+  ],
+  "displayName": "Kimberly Baker",
+  "emails": [
+    {
+      "type": "work",
+      "primary": true,
+      "value": "anna33@example.com"
+    },
+    {
+      "type": "other",
+      "primary": false,
+      "value": "anna33@gmail.com"
+    }
+  ],
+  "meta": {
+    "created": "2019-09-18T18:15:26.5788954+00:00",
+    "lastModified": "2019-09-18T18:15:26.5788976+00:00",
+    "resourceType": "User"
+  },
+  "name": {
+    "formatted": "Daniel Mcgee",
+    "familyName": "OMalley",
+    "givenName": "Darl",
+    "honorificPrefix": null,
+    "honorificSuffix": null
+  },
+  "phoneNumbers": [
+    {
+      "type": "fax",
+      "primary": false,
+      "value": "312-320-0500"
+    },
+    {
+      "type": "mobile",
+      "primary": false,
+      "value": "312-320-1707"
+    },
+    {
+      "type": "work",
+      "primary": true,
+      "value": "312-320-0932"
+    }
+  ],
+  "preferredLanguage": "xh",
+  "roles": [],
+  "title": "Site engineer",
+  "externalId": "22fbc523-6032-4c5f-939d-5d4850cf3e52",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/put_omalley_nouname.json b/Microsoft.SCIM.PlaywrightTests/json/put_omalley_nouname.json
new file mode 100644
index 00000000..057719e5
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/put_omalley_nouname.json
@@ -0,0 +1,76 @@
+{
+  "id" : "{{1stuserid}}",
+  "userame": "OMalley",
+  "active": false,
+  "addresses": [
+    {
+      "country": "Germany",
+      "formatted": "1923 Jennifer Way Suite 040\nSouth Nancy, MI 55645",
+      "locality": "East Mercedes",
+      "postalCode": "99265",
+      "region": "Montana",
+      "streetAddress": "4939 Hess Fork",
+      "type": "work",
+      "primary": false
+    },
+    {
+      "country": "bahams",
+      "formatted": "18522 Lisa Unions\nEast Gregory, CT 52311",
+      "locality": null,
+      "postalCode": null,
+      "region": null,
+      "streetAddress": null,
+      "type": "other",
+      "primary": false
+    }
+  ],
+  "displayName": "Kimberly Baker",
+  "emails": [
+    {
+      "type": "work",
+      "primary": true,
+      "value": "anna33@example.com"
+    },
+    {
+      "type": "other",
+      "primary": false,
+      "value": "anna33@gmail.com"
+    }
+  ],
+  "meta": {
+    "created": "2019-09-18T18:15:26.5788954+00:00",
+    "lastModified": "2019-09-18T18:15:26.5788976+00:00",
+    "resourceType": "User"
+  },
+  "name": {
+    "formatted": "Daniel Mcgee",
+    "familyName": "OMalley",
+    "givenName": "Darl",
+    "honorificPrefix": null,
+    "honorificSuffix": null
+  },
+  "phoneNumbers": [
+    {
+      "type": "fax",
+      "primary": false,
+      "value": "312-320-0500"
+    },
+    {
+      "type": "mobile",
+      "primary": false,
+      "value": "312-320-1707"
+    },
+    {
+      "type": "work",
+      "primary": true,
+      "value": "312-320-0932"
+    }
+  ],
+  "preferredLanguage": "xh",
+  "roles": [],
+  "title": "Site engineer",
+  "externalId": "22fbc523-6032-4c5f-939d-5d4850cf3e52",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/put_omalley_typo.json b/Microsoft.SCIM.PlaywrightTests/json/put_omalley_typo.json
new file mode 100644
index 00000000..e19609a3
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/put_omalley_typo.json
@@ -0,0 +1,76 @@
+{
+  "id" : "{{1stuserid}}",
+  "userName": "OMalley",
+  "active": false,
+  "adreses": [
+    {
+      "country": "Germany",
+      "formatted": "1923 Jennifer Way Suite 040\nSouth Nancy, MI 55645",
+      "locality": "East Mercedes",
+      "postalCode": "99265",
+      "region": "Montana",
+      "streetAddress": "4939 Hess Fork",
+      "type": "work",
+      "primary": false
+    },
+    {
+      "country": "bahams",
+      "formatted": "18522 Lisa Unions\nEast Gregory, CT 52311",
+      "locality": null,
+      "postalCode": null,
+      "region": null,
+      "streetAddress": null,
+      "type": "other",
+      "primary": false
+    }
+  ],
+  "displayName": "Kimberly Baker",
+  "emails": [
+    {
+      "type": "work",
+      "primary": true,
+      "value": "anna33@example.com"
+    },
+    {
+      "type": "other",
+      "primary": false,
+      "value": "anna33@gmail.com"
+    }
+  ],
+  "meta": {
+    "created": "2019-09-18T18:15:26.5788954+00:00",
+    "lastModified": "2019-09-18T18:15:26.5788976+00:00",
+    "resourceType": "User"
+  },
+  "name": {
+    "formatted": "Daniel Mcgee",
+    "familyName": "OMalley",
+    "givenName": "Darl",
+    "honorificPrefix": null,
+    "honorificSuffix": null
+  },
+  "phoneNumbers": [
+    {
+      "type": "fax",
+      "primary": false,
+      "value": "312-320-0500"
+    },
+    {
+      "type": "mobile",
+      "primary": false,
+      "value": "312-320-1707"
+    },
+    {
+      "type": "work",
+      "primary": true,
+      "value": "312-320-0932"
+    }
+  ],
+  "preferredLanguage": "xh",
+  "roles": [],
+  "title": "Site engineer",
+  "externalId": "22fbc523-6032-4c5f-939d-5d4850cf3e52",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/put_user2.json b/Microsoft.SCIM.PlaywrightTests/json/put_user2.json
new file mode 100644
index 00000000..d9f1d096
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/put_user2.json
@@ -0,0 +1,28 @@
+{
+  "userName": "UserNameReplace2",
+  "active": true,
+  "displayName": "BobIsAmazing",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User",
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ],
+  "id": "{{id2}}",
+  "externalId": "${__UUID}",
+  "name": {
+    "formatted": "NewName",
+    "familyName": "Leenay",
+    "givenName": "Ryan"
+  },
+  "emails": [
+    {
+      "Primary": true,
+      "type": "work",
+      "value": "testing@bobREPLACE.com"
+    },
+    {
+      "Primary": false,
+      "type": "home",
+      "value": "testinghome@bob.com"
+    }
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user1.json b/Microsoft.SCIM.PlaywrightTests/json/user1.json
new file mode 100644
index 00000000..84144c49
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user1.json
@@ -0,0 +1,26 @@
+{
+  "userName": "UserName123",
+  "active": true,
+  "displayName": "BobIsAmazing",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ],
+  "externalId": "${__UUID}",
+  "name": {
+    "formatted": "Ryan Leenay",
+    "familyName": "Leenay",
+    "givenName": "Ryan"
+  },
+  "emails": [
+    {
+      "Primary": true,
+      "type": "work",
+      "value": "testing@bob.com"
+    },
+    {
+      "Primary": false,
+      "type": "home",
+      "value": "testinghome@bob.com"
+    }
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user2.json b/Microsoft.SCIM.PlaywrightTests/json/user2.json
new file mode 100644
index 00000000..f8994748
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user2.json
@@ -0,0 +1,31 @@
+{
+  "userName": "UserName222",
+  "active": true,
+  "displayName": "lennay",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User",
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ],
+  "externalId": "${__UUID}",
+  "name": {
+    "formatted": "Adrew Ryan",
+    "familyName": "Ryan",
+    "givenName": "Andrew"
+  },
+  "emails": [
+    {
+      "Primary": true,
+      "type": "work",
+      "value": "testing@bob2.com"
+    },
+    {
+      "Primary": false,
+      "type": "home",
+      "value": "testinghome@bob3.com"
+    }
+  ],
+  "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User": {
+    "Department": "bob",
+    "Manager" : { "Value": "SuzzyQ" }
+  }
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user3.json b/Microsoft.SCIM.PlaywrightTests/json/user3.json
new file mode 100644
index 00000000..eaf702f4
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user3.json
@@ -0,0 +1,27 @@
+{
+  "userName": "UserName333",
+  "active": true,
+  "displayName": "lennay",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User",
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ],
+  "externalId": "${__UUID}",
+  "name": {
+    "formatted": "Adrew Ryan",
+    "familyName": "Ryan",
+    "givenName": "Andrew"
+  },
+  "emails": [
+    {
+      "Primary": true,
+      "type": "work",
+      "value": "testing@bob2.com"
+    },
+    {
+      "Primary": false,
+      "type": "home",
+      "value": "testinghome@bob3.com"
+    }
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user4.json b/Microsoft.SCIM.PlaywrightTests/json/user4.json
new file mode 100644
index 00000000..d986bb49
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user4.json
@@ -0,0 +1,27 @@
+{
+  "userName": "UserName444",
+  "active": true,
+  "displayName": "lennay",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User",
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ],
+  "externalId": "${__UUID}",
+  "name": {
+    "formatted": "Adrew Ryan",
+    "familyName": "Ryan",
+    "givenName": "Andrew"
+  },
+  "emails": [
+    {
+      "Primary": true,
+      "type": "work",
+      "value": "testing@bob2.com"
+    },
+    {
+      "Primary": false,
+      "type": "home",
+      "value": "testinghome@bob3.com"
+    }
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user_emp1.json b/Microsoft.SCIM.PlaywrightTests/json/user_emp1.json
new file mode 100644
index 00000000..6f004514
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user_emp1.json
@@ -0,0 +1,75 @@
+{
+  "userName": "emp1",
+  "active": "True",
+  "addresses": [
+    {
+      "country": "Bermuda",
+      "formatted": "9132 Jennifer Way Suite 040\nSouth Nancy, MI 55645",
+      "locality": "West Mercedes",
+      "postalCode": "99265",
+      "region": "Montana",
+      "streetAddress": "4939 Hess Fork",
+      "type": "work",
+      "primary": false
+    },
+    {
+      "country": null,
+      "formatted": "18522 Lisa Unions\nEast Gregory, CT 52311",
+      "locality": null,
+      "postalCode": null,
+      "region": null,
+      "streetAddress": null,
+      "type": "other",
+      "primary": false
+    }
+  ],
+  "displayName": "Kimberly Baker",
+  "emails": [
+    {
+      "type": "work",
+      "primary": true,
+      "value": "anna33@gmail.com"
+    },
+    {
+      "type": "work",
+      "primary": false,
+      "value": "anna33@example.com"
+    }
+  ],
+  "meta": {
+    "created": "2019-09-18T18:15:26.5788954+00:00",
+    "lastModified": "2019-09-18T18:15:26.5788976+00:00",
+    "resourceType": "User"
+  },
+  "name": {
+    "formatted": "Daniel Mcgee",
+    "familyName": "Employee",
+    "givenName": "Darl",
+    "honorificPrefix": null,
+    "honorificSuffix": null
+  },
+  "phoneNumbers": [
+    {
+      "type": "fax",
+      "primary": false,
+      "value": "312-320-0500"
+    },
+    {
+      "type": "mobile",
+      "primary": false,
+      "value": "312-320-1707"
+    },
+    {
+      "type": "work",
+      "primary": true,
+      "value": "312-320-0932"
+    }
+  ],
+  "preferredLanguage": "xh",
+  "roles": [],
+  "title": "Site engineer",
+  "externalId": "22fbc523-6032-4c5f-939d-5d4850cf3e52",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user_emp2.json b/Microsoft.SCIM.PlaywrightTests/json/user_emp2.json
new file mode 100644
index 00000000..4c3e8094
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user_emp2.json
@@ -0,0 +1,75 @@
+{
+  "userName": "emp2",
+  "active": true,
+  "addresses": [
+    {
+      "country": "Bermuda",
+      "formatted": "9132 Jennifer Way Suite 040\nSouth Nancy, MI 55645",
+      "locality": "West Mercedes",
+      "postalCode": "99265",
+      "region": "Montana",
+      "streetAddress": "4939 Hess Fork",
+      "type": "work",
+      "primary": false
+    },
+    {
+      "country": null,
+      "formatted": "18522 Lisa Unions\nEast Gregory, CT 52311",
+      "locality": null,
+      "postalCode": null,
+      "region": null,
+      "streetAddress": null,
+      "type": "other",
+      "primary": false
+    }
+  ],
+  "displayName": "Kimberly Baker",
+  "emails": [
+    {
+      "type": "work",
+      "primary": true,
+      "value": "anna33@gmail.com"
+    },
+    {
+      "type": "work",
+      "primary": false,
+      "value": "anna33@example.com"
+    }
+  ],
+  "meta": {
+    "created": "2019-09-18T18:15:26.5788954+00:00",
+    "lastModified": "2019-09-18T18:15:26.5788976+00:00",
+    "resourceType": "User"
+  },
+  "name": {
+    "formatted": "Daniel Mcgee",
+    "familyName": "Employee",
+    "givenName": "Darl",
+    "honorificPrefix": null,
+    "honorificSuffix": null
+  },
+  "phoneNumbers": [
+    {
+      "type": "fax",
+      "primary": false,
+      "value": "312-320-0500"
+    },
+    {
+      "type": "mobile",
+      "primary": false,
+      "value": "312-320-1707"
+    },
+    {
+      "type": "work",
+      "primary": true,
+      "value": "312-320-0932"
+    }
+  ],
+  "preferredLanguage": "xh",
+  "roles": [],
+  "title": "Site engineer",
+  "externalId": "22fbc523-6032-4c5f-939d-5d4850cf3e52",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user_emp3.json b/Microsoft.SCIM.PlaywrightTests/json/user_emp3.json
new file mode 100644
index 00000000..f1a8d7d6
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user_emp3.json
@@ -0,0 +1,75 @@
+{
+  "userName": "emp3",
+  "active": true,
+  "addresses": [
+    {
+      "country": "Bermuda",
+      "formatted": "9132 Jennifer Way Suite 040\nSouth Nancy, MI 55645",
+      "locality": "West Mercedes",
+      "postalCode": "99265",
+      "region": "Montana",
+      "streetAddress": "4939 Hess Fork",
+      "type": "work",
+      "primary": false
+    },
+    {
+      "country": null,
+      "formatted": "18522 Lisa Unions\nEast Gregory, CT 52311",
+      "locality": null,
+      "postalCode": null,
+      "region": null,
+      "streetAddress": null,
+      "type": "other",
+      "primary": false
+    }
+  ],
+  "displayName": "Kimberly Baker",
+  "emails": [
+    {
+      "type": "work",
+      "primary": true,
+      "value": "anna33@gmail.com"
+    },
+    {
+      "type": "work",
+      "primary": false,
+      "value": "anna33@example.com"
+    }
+  ],
+  "meta": {
+    "created": "2019-09-18T18:15:26.5788954+00:00",
+    "lastModified": "2019-09-18T18:15:26.5788976+00:00",
+    "resourceType": "User"
+  },
+  "name": {
+    "formatted": "Daniel Mcgee",
+    "familyName": "Employee",
+    "givenName": "Darl",
+    "honorificPrefix": null,
+    "honorificSuffix": null
+  },
+  "phoneNumbers": [
+    {
+      "type": "fax",
+      "primary": false,
+      "value": "312-320-0500"
+    },
+    {
+      "type": "mobile",
+      "primary": false,
+      "value": "312-320-1707"
+    },
+    {
+      "type": "work",
+      "primary": true,
+      "value": "312-320-0932"
+    }
+  ],
+  "preferredLanguage": "xh",
+  "roles": [],
+  "title": "Site engineer",
+  "externalId": "22fbc523-6032-4c5f-939d-5d4850cf3e52",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user_enterprise.json b/Microsoft.SCIM.PlaywrightTests/json/user_enterprise.json
new file mode 100644
index 00000000..6a44d8e0
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user_enterprise.json
@@ -0,0 +1,79 @@
+{
+  "userName": "enterprise",
+  "active": true,
+  "addresses": [
+    {
+      "country": "Bermuda",
+      "formatted": "9132 Jennifer Way Suite 040\nSouth Nancy, MI 55645",
+      "locality": "West Mercedes",
+      "postalCode": "99265",
+      "region": "Montana",
+      "streetAddress": "4939 Hess Fork",
+      "type": "work",
+      "primary": false
+    },
+    {
+      "country": null,
+      "formatted": "18522 Lisa Unions\nEast Gregory, CT 52311",
+      "locality": null,
+      "postalCode": null,
+      "region": null,
+      "streetAddress": null,
+      "type": "other",
+      "primary": false
+    }
+  ],
+  "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User": {
+    "Department": "some department"
+  },
+  "displayName": "Kimberly Baker",
+  "emails": [
+    {
+      "type": "work",
+      "primary": true,
+      "value": "anna33@gmail.com"
+    },
+    {
+      "type": "work",
+      "primary": false,
+      "value": "anna33@example.com"
+    }
+  ],
+  "meta": {
+    "created": "2019-09-18T18:15:26.5788954+00:00",
+    "lastModified": "2019-09-18T18:15:26.5788976+00:00",
+    "resourceType": "User"
+  },
+  "name": {
+    "formatted": "Daniel Mcgee",
+    "familyName": "Employee",
+    "givenName": "Darl",
+    "honorificPrefix": null,
+    "honorificSuffix": null
+  },
+  "phoneNumbers": [
+    {
+      "type": "fax",
+      "primary": false,
+      "value": "312-320-0500"
+    },
+    {
+      "type": "mobile",
+      "primary": false,
+      "value": "312-320-1707"
+    },
+    {
+      "type": "work",
+      "primary": true,
+      "value": "312-320-0932"
+    }
+  ],
+  "preferredLanguage": "xh",
+  "roles": [],
+  "title": "Site engineer",
+  "externalId": "22fbc523-6032-4c5f-939d-5d4850cf3e52",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:User",
+    "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user_junk.json b/Microsoft.SCIM.PlaywrightTests/json/user_junk.json
new file mode 100644
index 00000000..da6f4e88
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user_junk.json
@@ -0,0 +1,24 @@
+{
+  "acve": tre,
+  "adadfdresses": [
+    {
+      "coudftry": "Beruda",
+      "formatted": "9132 Jennifer Way Suite 040\nSouth Nancy, MI 55645",
+      "locality": "West Mercedes",
+      "postalCode": "99265",
+      "region": "Montana",
+      "streetAddress": "4939 Hess Fork",
+      "type": "work",
+      "primary": false
+    },
+    {
+      "country": null,
+      "formatted": "18522 Lisa Unions\nEast Gregory, CT 52311",
+      "locality": null,
+      les": [],
+      "title": "Site engineer",
+      "externalId": "22fbc523-6032-4c5f-939d-5d4850cf3e52",
+      "schemas": [
+        "urn:ietf:params:scim:schemas:core:2.0:User"
+      ]
+    }
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user_noname.json b/Microsoft.SCIM.PlaywrightTests/json/user_noname.json
new file mode 100644
index 00000000..0686a5b0
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user_noname.json
@@ -0,0 +1,74 @@
+{
+  "active": true,
+  "addresses": [
+    {
+      "country": "Bermuda",
+      "formatted": "9132 Jennifer Way Suite 040\nSouth Nancy, MI 55645",
+      "locality": "West Mercedes",
+      "postalCode": "99265",
+      "region": "Montana",
+      "streetAddress": "4939 Hess Fork",
+      "type": "work",
+      "primary": false
+    },
+    {
+      "country": null,
+      "formatted": "18522 Lisa Unions\nEast Gregory, CT 52311",
+      "locality": null,
+      "postalCode": null,
+      "region": null,
+      "streetAddress": null,
+      "type": "other",
+      "primary": false
+    }
+  ],
+  "displayName": "Kimberly Baker",
+  "emails": [
+    {
+      "type": "work",
+      "primary": true,
+      "value": "anna33@gmail.com"
+    },
+    {
+      "type": "work",
+      "primary": false,
+      "value": "anna33@example.com"
+    }
+  ],
+  "meta": {
+    "created": "2019-09-18T18:15:26.5788954+00:00",
+    "lastModified": "2019-09-18T18:15:26.5788976+00:00",
+    "resourceType": "User"
+  },
+  "name": {
+    "formatted": "Daniel Mcgee",
+    "familyName": "Employee",
+    "givenName": "Darl",
+    "honorificPrefix": null,
+    "honorificSuffix": null
+  },
+  "phoneNumbers": [
+    {
+      "type": "fax",
+      "primary": false,
+      "value": "312-320-0500"
+    },
+    {
+      "type": "mobile",
+      "primary": false,
+      "value": "312-320-1707"
+    },
+    {
+      "type": "work",
+      "primary": true,
+      "value": "312-320-0932"
+    }
+  ],
+  "preferredLanguage": "xh",
+  "roles": [],
+  "title": "Site engineer",
+  "externalId": "22fbc523-6032-4c5f-939d-5d4850cf3e52",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ]
+}
diff --git a/Microsoft.SCIM.PlaywrightTests/json/user_omalley.json b/Microsoft.SCIM.PlaywrightTests/json/user_omalley.json
new file mode 100644
index 00000000..08c4f44d
--- /dev/null
+++ b/Microsoft.SCIM.PlaywrightTests/json/user_omalley.json
@@ -0,0 +1,75 @@
+{
+  "userName": "OMalley",
+  "active": true,
+  "addresses": [
+    {
+      "country": "Bermuda",
+      "formatted": "9132 Jennifer Way Suite 040\nSouth Nancy, MI 55645",
+      "locality": "West Mercedes",
+      "postalCode": "99265",
+      "region": "Montana",
+      "streetAddress": "4939 Hess Fork",
+      "type": "work",
+      "primary": false
+    },
+    {
+      "country": null,
+      "formatted": "18522 Lisa Unions\nEast Gregory, CT 52311",
+      "locality": null,
+      "postalCode": null,
+      "region": null,
+      "streetAddress": null,
+      "type": "other",
+      "primary": false
+    }
+  ],
+  "displayName": "Kimberly Baker",
+  "emails": [
+    {
+      "type": "work",
+      "primary": true,
+      "value": "anna33@example.com"
+    },
+    {
+      "type": "other",
+      "primary": false,
+      "value": "anna33@gmail.com"
+    }
+  ],
+  "meta": {
+    "created": "2019-09-18T18:15:26.5788954+00:00",
+    "lastModified": "2019-09-18T18:15:26.5788976+00:00",
+    "resourceType": "User"
+  },
+  "name": {
+    "formatted": "Daniel Mcgee",
+    "familyName": "OMalley",
+    "givenName": "Darl",
+    "honorificPrefix": null,
+    "honorificSuffix": null
+  },
+  "phoneNumbers": [
+    {
+      "type": "fax",
+      "primary": false,
+      "value": "312-320-0500"
+    },
+    {
+      "type": "mobile",
+      "primary": false,
+      "value": "312-320-1707"
+    },
+    {
+      "type": "work",
+      "primary": true,
+      "value": "312-320-0932"
+    }
+  ],
+  "preferredLanguage": "xh",
+  "roles": [],
+  "title": "Site engineer",
+  "externalId": "22fbc523-6032-4c5f-939d-5d4850cf3e52",
+  "schemas": [
+    "urn:ietf:params:scim:schemas:core:2.0:User"
+  ]
+}
diff --git a/Microsoft.SCIM.WebHostSample/Microsoft.SCIM.WebHostSample.csproj b/Microsoft.SCIM.WebHostSample/Microsoft.SCIM.WebHostSample.csproj
index 15a8edcb..2e663d08 100644
--- a/Microsoft.SCIM.WebHostSample/Microsoft.SCIM.WebHostSample.csproj
+++ b/Microsoft.SCIM.WebHostSample/Microsoft.SCIM.WebHostSample.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/Microsoft.SCIM.WebHostSample/Provider/InMemoryGroupProvider.cs b/Microsoft.SCIM.WebHostSample/Provider/InMemoryGroupProvider.cs
index 6dba20a8..145d59ce 100644
--- a/Microsoft.SCIM.WebHostSample/Provider/InMemoryGroupProvider.cs
+++ b/Microsoft.SCIM.WebHostSample/Provider/InMemoryGroupProvider.cs
@@ -8,7 +8,6 @@ namespace Microsoft.SCIM.WebHostSample.Provider
     using System.Linq.Expressions;
     using System.Net;
     using System.Threading.Tasks;
-    using System.Web.Http;
     using Microsoft.SCIM;
 
     public class InMemoryGroupProvider : ProviderBase
@@ -20,18 +19,18 @@ public InMemoryGroupProvider()
             this.storage = InMemoryStorage.Instance;
         }
 
-        public override Task<Resource> CreateAsync(Resource resource, string correlationIdentifier)
+        public override Task<Resource>CreateAsync(Resource resource, string correlationIdentifier)
         {
             if (resource.Identifier != null)
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
 
             Core2Group group = resource as Core2Group;
 
             if (string.IsNullOrWhiteSpace(group.DisplayName))
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
 
             IEnumerable<Core2Group> exisitingGroups = this.storage.Groups.Values;
@@ -42,7 +41,7 @@ public override Task<Resource> CreateAsync(Resource resource, string correlation
                         string.Equals(exisitingGroup.DisplayName, group.DisplayName, StringComparison.Ordinal))
             )
             {
-                throw new HttpResponseException(HttpStatusCode.Conflict);
+                throw new CustomHttpResponseException(HttpStatusCode.Conflict);
             }
             //Update Metadata
             DateTime created = DateTime.UtcNow;
@@ -56,21 +55,23 @@ public override Task<Resource> CreateAsync(Resource resource, string correlation
             return Task.FromResult(resource);
         }
 
-        public override Task DeleteAsync(IResourceIdentifier resourceIdentifier, string correlationIdentifier)
+        public override Task<Resource> DeleteAsync(IResourceIdentifier resourceIdentifier,
+            string correlationIdentifier)
         {
             if (string.IsNullOrWhiteSpace(resourceIdentifier?.Identifier))
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
 
             string identifier = resourceIdentifier.Identifier;
 
             if (this.storage.Groups.ContainsKey(identifier))
             {
+                var group = this.storage.Groups[identifier];
                 this.storage.Groups.Remove(identifier);
+                return Task.FromResult(group as Resource);
             }
-
-            return Task.CompletedTask;
+            throw new CustomHttpResponseException(HttpStatusCode.NotFound);
         }
 
         public override Task<Resource[]> QueryAsync(IQueryParameters parameters, string correlationIdentifier)
@@ -121,23 +122,23 @@ public override Task<Resource[]> QueryAsync(IQueryParameters parameters, string
 
                 if (queryFilter.FilterOperator != ComparisonOperator.Equals)
                 {
-                    throw new NotSupportedException(string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterOperatorNotSupportedTemplate, queryFilter.FilterOperator));
+                    throw new ScimTypeException(ErrorType.invalidFilter,string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterOperatorNotSupportedTemplate, queryFilter.FilterOperator));
                 }
 
 
                 if (queryFilter.AttributePath.Equals(AttributeNames.DisplayName))
                 {
-                    
+
                     string displayName = queryFilter.ComparisonValue;
                     predicateAnd = predicateAnd.And(p => string.Equals(p.DisplayName, displayName, StringComparison.OrdinalIgnoreCase));
-                  
+
                 }
                 else
                 {
-                    throw new NotSupportedException(string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterAttributePathNotSupportedTemplate, queryFilter.AttributePath));
+                    throw new ScimTypeException(ErrorType.invalidFilter,string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterAttributePathNotSupportedTemplate, queryFilter.AttributePath));
                 }
             }
-            
+
             predicate = predicate.Or(predicateAnd);
             results = this.storage.Groups.Values.Where(predicate.Compile());
 
@@ -148,14 +149,14 @@ public override Task<Resource> ReplaceAsync(Resource resource, string correlatio
         {
             if (resource.Identifier == null)
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
 
             Core2Group group = resource as Core2Group;
 
             if (string.IsNullOrWhiteSpace(group.DisplayName))
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
 
             Core2Group exisitingGroups = resource as Core2Group;
@@ -167,12 +168,12 @@ public override Task<Resource> ReplaceAsync(Resource resource, string correlatio
                         !string.Equals(exisitingUser.Identifier, group.Identifier, StringComparison.OrdinalIgnoreCase))
             )
             {
-                throw new HttpResponseException(HttpStatusCode.Conflict);
+                throw new CustomHttpResponseException(HttpStatusCode.Conflict);
             }
 
             if (!this.storage.Groups.TryGetValue(group.Identifier, out Core2Group _))
             {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
+                throw new CustomHttpResponseException(HttpStatusCode.NotFound);
             }
 
             // Update metadata
@@ -211,11 +212,10 @@ public override Task<Resource> RetrieveAsync(IResourceRetrievalParameters parame
                     return Task.FromResult(result);
                 }
             }
-
-            throw new HttpResponseException(HttpStatusCode.NotFound);
+            throw new CustomHttpResponseException(HttpStatusCode.NotFound);
         }
 
-        public override Task UpdateAsync(IPatch patch, string correlationIdentifier)
+        public override Task<Resource> UpdateAsync(IPatch patch, string correlationIdentifier)
         {
             if (null == patch)
             {
@@ -254,10 +254,10 @@ public override Task UpdateAsync(IPatch patch, string correlationIdentifier)
             }
             else
             {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
+                throw new CustomHttpResponseException(HttpStatusCode.NotFound);
             }
 
-            return Task.CompletedTask;
+            return Task.FromResult(group as Resource);
         }
     }
 }
diff --git a/Microsoft.SCIM.WebHostSample/Provider/InMemoryProvider.cs b/Microsoft.SCIM.WebHostSample/Provider/InMemoryProvider.cs
index 70bf1cd6..5b19f12f 100644
--- a/Microsoft.SCIM.WebHostSample/Provider/InMemoryProvider.cs
+++ b/Microsoft.SCIM.WebHostSample/Provider/InMemoryProvider.cs
@@ -17,9 +17,9 @@ public class InMemoryProvider : ProviderBase
             new Lazy<IReadOnlyCollection<TypeScheme>>(
                 () =>
                     new TypeScheme[]
-                    { 
+                    {
                         SampleTypeScheme.UserTypeScheme,
-                        SampleTypeScheme.GroupTypeScheme, 
+                        SampleTypeScheme.GroupTypeScheme,
                         SampleTypeScheme.EnterpriseUserTypeScheme,
                         SampleTypeScheme.ResourceTypesTypeScheme,
                         SampleTypeScheme.SchemaTypeScheme,
@@ -39,9 +39,9 @@ public InMemoryProvider()
         }
 
         public override IReadOnlyCollection<Core2ResourceType> ResourceTypes => InMemoryProvider.Types.Value;
-       
+
         public override IReadOnlyCollection<TypeScheme> Schema => InMemoryProvider.TypeSchema.Value;
-        
+
         public override Task<Resource> CreateAsync(Resource resource, string correlationIdentifier)
         {
             if (resource is Core2EnterpriseUser)
@@ -57,7 +57,7 @@ public override Task<Resource> CreateAsync(Resource resource, string correlation
             throw new NotImplementedException();
         }
 
-        public override Task DeleteAsync(IResourceIdentifier resourceIdentifier, string correlationIdentifier)
+        public override Task<Resource> DeleteAsync(IResourceIdentifier resourceIdentifier, string correlationIdentifier)
         {
             if (resourceIdentifier.SchemaIdentifier.Equals(SchemaIdentifiers.Core2EnterpriseUser))
             {
@@ -87,6 +87,21 @@ public override Task<Resource[]> QueryAsync(IQueryParameters parameters, string
             throw new NotImplementedException();
         }
 
+        public override Task<QueryResponseBase> PaginateQueryAsync(IRequest<IQueryParameters> request)
+        {
+            if (request.Payload.SchemaIdentifier.Equals(SchemaIdentifiers.Core2EnterpriseUser))
+            {
+                return this.userProvider.PaginateQueryAsync(request);
+            }
+
+            if (request.Payload.SchemaIdentifier.Equals(SchemaIdentifiers.Core2Group))
+            {
+                return this.groupProvider.PaginateQueryAsync(request);
+            }
+
+            throw new NotImplementedException();
+        }
+
         public override Task<Resource> ReplaceAsync(Resource resource, string correlationIdentifier)
         {
             if (resource is Core2EnterpriseUser)
@@ -117,7 +132,7 @@ public override Task<Resource> RetrieveAsync(IResourceRetrievalParameters parame
             throw new NotImplementedException();
         }
 
-        public override Task UpdateAsync(IPatch patch, string correlationIdentifier)
+        public override Task<Resource> UpdateAsync(IPatch patch, string correlationIdentifier)
         {
             if (patch == null)
             {
diff --git a/Microsoft.SCIM.WebHostSample/Provider/InMemoryUserProvider.cs b/Microsoft.SCIM.WebHostSample/Provider/InMemoryUserProvider.cs
index 8fad98d8..e5105188 100644
--- a/Microsoft.SCIM.WebHostSample/Provider/InMemoryUserProvider.cs
+++ b/Microsoft.SCIM.WebHostSample/Provider/InMemoryUserProvider.cs
@@ -8,7 +8,6 @@ namespace Microsoft.SCIM.WebHostSample.Provider
     using System.Linq.Expressions;
     using System.Net;
     using System.Threading.Tasks;
-    using System.Web.Http;
     using Microsoft.SCIM;
 
     public class InMemoryUserProvider : ProviderBase
@@ -24,13 +23,13 @@ public override Task<Resource> CreateAsync(Resource resource, string correlation
         {
             if (resource.Identifier != null)
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
 
             Core2EnterpriseUser user = resource as Core2EnterpriseUser;
             if (string.IsNullOrWhiteSpace(user.UserName))
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
 
             IEnumerable<Core2EnterpriseUser> exisitingUsers = this.storage.Users.Values;
@@ -41,14 +40,14 @@ public override Task<Resource> CreateAsync(Resource resource, string correlation
                         string.Equals(exisitingUser.UserName, user.UserName, StringComparison.Ordinal))
             )
             {
-                throw new HttpResponseException(HttpStatusCode.Conflict);
+                throw new CustomHttpResponseException(HttpStatusCode.Conflict);
             }
 
             // Update metadata
             DateTime created = DateTime.UtcNow;
             user.Metadata.Created = created;
-            user.Metadata.LastModified = created; 
-            
+            user.Metadata.LastModified = created;
+
             string resourceIdentifier = Guid.NewGuid().ToString();
             resource.Identifier = resourceIdentifier;
             this.storage.Users.Add(resourceIdentifier, user);
@@ -56,21 +55,48 @@ public override Task<Resource> CreateAsync(Resource resource, string correlation
             return Task.FromResult(resource);
         }
 
-        public override Task DeleteAsync(IResourceIdentifier resourceIdentifier, string correlationIdentifier)
+        public override Task<Resource> DeleteAsync(IResourceIdentifier resourceIdentifier,
+            string correlationIdentifier)
         {
             if (string.IsNullOrWhiteSpace(resourceIdentifier?.Identifier))
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
 
             string identifier = resourceIdentifier.Identifier;
 
             if (this.storage.Users.ContainsKey(identifier))
             {
+                Core2EnterpriseUser user = this.storage.Users[identifier];
                 this.storage.Users.Remove(identifier);
+                return Task.FromResult((Resource)user);
             }
 
-            return Task.CompletedTask;
+            throw new CustomHttpResponseException(HttpStatusCode.NotFound);
+        }
+
+        public override async Task<QueryResponseBase> PaginateQueryAsync(IRequest<IQueryParameters> request)
+        {
+            if (null == request)
+            {
+                throw new ArgumentNullException(nameof(request));
+            }
+
+            IReadOnlyCollection<Resource> resources = await this.QueryAsync(request).ConfigureAwait(false);
+            int totalCount = resources.Count;
+            if (request.Payload.PaginationParameters != null)
+            {
+                int count = request.Payload.PaginationParameters?.Count ?? 0;
+                resources = (IReadOnlyCollection<Resource>)resources.Take(count);
+            }
+
+
+            QueryResponseBase result = new QueryResponse(resources);
+            result.TotalResults = totalCount;
+            result.ItemsPerPage = resources.Count;
+
+            result.StartIndex = resources.Any() ? 1 : null;
+            return result;
         }
 
         public override Task<Resource[]> QueryAsync(IQueryParameters parameters, string correlationIdentifier)
@@ -87,12 +113,14 @@ public override Task<Resource[]> QueryAsync(IQueryParameters parameters, string
 
             if (null == parameters.AlternateFilters)
             {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidParameters);
+                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources
+                    .ExceptionInvalidParameters);
             }
 
             if (string.IsNullOrWhiteSpace(parameters.SchemaIdentifier))
             {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidParameters);
+                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources
+                    .ExceptionInvalidParameters);
             }
 
             IEnumerable<Resource> results;
@@ -107,7 +135,6 @@ public override Task<Resource[]> QueryAsync(IQueryParameters parameters, string
             }
             else
             {
-
                 foreach (IFilter queryFilter in parameters.AlternateFilters)
                 {
                     predicateAnd = PredicateBuilder.True<Core2EnterpriseUser>();
@@ -118,119 +145,152 @@ public override Task<Resource[]> QueryAsync(IQueryParameters parameters, string
                     {
                         if (string.IsNullOrWhiteSpace(andFilter.AttributePath))
                         {
-                            throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidParameters);
+                            throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources
+                                .ExceptionInvalidParameters);
                         }
 
                         else if (string.IsNullOrWhiteSpace(andFilter.ComparisonValue))
                         {
-                            throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidParameters);
+                            throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources
+                                .ExceptionInvalidParameters);
+                        }
+
+                        // ID filter
+                        else if (andFilter.AttributePath.Equals(AttributeNames.Identifier,
+                                     StringComparison.OrdinalIgnoreCase))
+                        {
+                            if (andFilter.FilterOperator != ComparisonOperator.Equals)
+                            {
+                                throw new ScimTypeException(ErrorType.invalidFilter,
+                                    string.Format(
+                                        SystemForCrossDomainIdentityManagementServiceResources
+                                            .ExceptionFilterOperatorNotSupportedTemplate, andFilter.FilterOperator));
+                            }
+
+                            var id = andFilter.ComparisonValue;
+                            predicateAnd = predicateAnd.And(p =>
+                                string.Equals(p.Identifier, id, StringComparison.OrdinalIgnoreCase));
                         }
 
                         // UserName filter
-                        else if (andFilter.AttributePath.Equals(AttributeNames.UserName, StringComparison.OrdinalIgnoreCase))
+                        else if (andFilter.AttributePath.Equals(AttributeNames.UserName,
+                                     StringComparison.OrdinalIgnoreCase))
                         {
                             if (andFilter.FilterOperator != ComparisonOperator.Equals)
                             {
-                                throw new NotSupportedException(
-                                    string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterOperatorNotSupportedTemplate, andFilter.FilterOperator));
+                                throw new ScimTypeException(ErrorType.invalidFilter,
+                                    string.Format(
+                                        SystemForCrossDomainIdentityManagementServiceResources
+                                            .ExceptionFilterOperatorNotSupportedTemplate,
+                                        andFilter.FilterOperator));
                             }
 
                             string userName = andFilter.ComparisonValue;
-                            predicateAnd = predicateAnd.And(p => string.Equals(p.UserName, userName, StringComparison.OrdinalIgnoreCase));
-
-                           
+                            predicateAnd = predicateAnd.And(p =>
+                                string.Equals(p.UserName, userName, StringComparison.OrdinalIgnoreCase));
                         }
 
                         // ExternalId filter
-                        else if (andFilter.AttributePath.Equals(AttributeNames.ExternalIdentifier, StringComparison.OrdinalIgnoreCase))
+                        else if (andFilter.AttributePath.Equals(AttributeNames.ExternalIdentifier,
+                                     StringComparison.OrdinalIgnoreCase))
                         {
                             if (andFilter.FilterOperator != ComparisonOperator.Equals)
                             {
-                                throw new NotSupportedException(
-                                    string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterOperatorNotSupportedTemplate, andFilter.FilterOperator));
+                                throw new ScimTypeException(ErrorType.invalidFilter,
+                                    string.Format(
+                                        SystemForCrossDomainIdentityManagementServiceResources
+                                            .ExceptionFilterOperatorNotSupportedTemplate, andFilter.FilterOperator));
                             }
 
                             string externalIdentifier = andFilter.ComparisonValue;
-                            predicateAnd = predicateAnd.And(p => string.Equals(p.ExternalIdentifier, externalIdentifier, StringComparison.OrdinalIgnoreCase));
-
-                           
+                            predicateAnd = predicateAnd.And(p => string.Equals(p.ExternalIdentifier, externalIdentifier,
+                                StringComparison.OrdinalIgnoreCase));
                         }
 
                         //Active Filter
-                        else if (andFilter.AttributePath.Equals(AttributeNames.Active, StringComparison.OrdinalIgnoreCase))
+                        else if (andFilter.AttributePath.Equals(AttributeNames.Active,
+                                     StringComparison.OrdinalIgnoreCase))
                         {
                             if (andFilter.FilterOperator != ComparisonOperator.Equals)
                             {
-                                throw new NotSupportedException(
-                                    string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterOperatorNotSupportedTemplate, andFilter.FilterOperator));
+                                throw new ScimTypeException(ErrorType.invalidFilter,
+                                    string.Format(
+                                        SystemForCrossDomainIdentityManagementServiceResources
+                                            .ExceptionFilterOperatorNotSupportedTemplate, andFilter.FilterOperator));
                             }
 
                             bool active = bool.Parse(andFilter.ComparisonValue);
                             predicateAnd = predicateAnd.And(p => p.Active == active);
+                        }
+
+                        // DisplayName Filter
+                        else if (andFilter.AttributePath.Equals(AttributeNames.DisplayName,
+                                     StringComparison.OrdinalIgnoreCase))
+                        {
+                            if (andFilter.FilterOperator != ComparisonOperator.Equals)
+                            {
+                                throw new ScimTypeException(ErrorType.invalidFilter,
+                                    string.Format(
+                                        SystemForCrossDomainIdentityManagementServiceResources
+                                            .ExceptionFilterOperatorNotSupportedTemplate, andFilter.FilterOperator));
+                            }
 
+                            var displayName = andFilter.ComparisonValue;
+                            predicateAnd = predicateAnd.And(p => p.DisplayName == displayName);
                         }
 
                         //LastModified filter
-                        else if (andFilter.AttributePath.Equals($"{AttributeNames.Metadata}.{AttributeNames.LastModified}", StringComparison.OrdinalIgnoreCase))
+                        else if (andFilter.AttributePath.Equals(
+                                     $"{AttributeNames.Metadata}.{AttributeNames.LastModified}",
+                                     StringComparison.OrdinalIgnoreCase))
                         {
                             if (andFilter.FilterOperator == ComparisonOperator.EqualOrGreaterThan)
                             {
                                 DateTime comparisonValue = DateTime.Parse(andFilter.ComparisonValue).ToUniversalTime();
                                 predicateAnd = predicateAnd.And(p => p.Metadata.LastModified >= comparisonValue);
-
-                               
                             }
                             else if (andFilter.FilterOperator == ComparisonOperator.EqualOrLessThan)
                             {
                                 DateTime comparisonValue = DateTime.Parse(andFilter.ComparisonValue).ToUniversalTime();
                                 predicateAnd = predicateAnd.And(p => p.Metadata.LastModified <= comparisonValue);
-
-                                
                             }
                             else
-                                throw new NotSupportedException(
-                                    string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterOperatorNotSupportedTemplate, andFilter.FilterOperator));
-
-
-
+                                throw new ScimTypeException(ErrorType.invalidFilter,
+                                    string.Format(
+                                        SystemForCrossDomainIdentityManagementServiceResources
+                                            .ExceptionFilterOperatorNotSupportedTemplate, andFilter.FilterOperator));
                         }
                         else
-                            throw new NotSupportedException(
-                                string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterAttributePathNotSupportedTemplate, andFilter.AttributePath));
+                            throw new ScimTypeException(ErrorType.invalidFilter,
+                                string.Format(
+                                    SystemForCrossDomainIdentityManagementServiceResources
+                                        .ExceptionFilterAttributePathNotSupportedTemplate, andFilter.AttributePath));
 
                         currentFilter = andFilter;
                         andFilter = andFilter.AdditionalFilter;
-
                     } while (currentFilter.AdditionalFilter != null);
 
                     predicate = predicate.Or(predicateAnd);
-
                 }
 
                 results = this.storage.Users.Values.Where(predicate.Compile());
             }
 
-            if (parameters.PaginationParameters != null)
-            {
-                int count = parameters.PaginationParameters.Count.HasValue ? parameters.PaginationParameters.Count.Value : 0;
-                return Task.FromResult(results.Take(count).ToArray());
-            }
-            else
-                return Task.FromResult(results.ToArray());
+            return Task.FromResult(results.ToArray());
         }
 
         public override Task<Resource> ReplaceAsync(Resource resource, string correlationIdentifier)
         {
             if (resource.Identifier == null)
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
 
             Core2EnterpriseUser user = resource as Core2EnterpriseUser;
 
             if (string.IsNullOrWhiteSpace(user.UserName))
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
 
             if
@@ -241,7 +301,9 @@ public override Task<Resource> ReplaceAsync(Resource resource, string correlatio
                         !string.Equals(exisitingUser.Identifier, user.Identifier, StringComparison.OrdinalIgnoreCase))
             )
             {
-                throw new HttpResponseException(HttpStatusCode.Conflict);
+                throw new ScimTypeException(ErrorType.uniqueness, string.Format(
+                    SystemForCrossDomainIdentityManagementServiceResources
+                        .ExceptionResourceConflict));
             }
 
             Core2EnterpriseUser exisitingUser = this.storage.Users.Values
@@ -251,7 +313,7 @@ public override Task<Resource> ReplaceAsync(Resource resource, string correlatio
                 );
             if (exisitingUser == null)
             {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
+                throw new CustomHttpResponseException(HttpStatusCode.NotFound);
             }
 
             // Update metadata
@@ -259,11 +321,11 @@ public override Task<Resource> ReplaceAsync(Resource resource, string correlatio
             user.Metadata.LastModified = DateTime.UtcNow;
 
             this.storage.Users[user.Identifier] = user;
-            Resource result = user as Resource;
-            return Task.FromResult(result);
+            return Task.FromResult(user as Resource);
         }
 
-        public override Task<Resource> RetrieveAsync(IResourceRetrievalParameters parameters, string correlationIdentifier)
+        public override Task<Resource> RetrieveAsync(IResourceRetrievalParameters parameters,
+            string correlationIdentifier)
         {
             if (parameters == null)
             {
@@ -280,22 +342,20 @@ public override Task<Resource> RetrieveAsync(IResourceRetrievalParameters parame
                 throw new ArgumentNullException(nameof(parameters));
             }
 
-            Resource result = null;
             string identifier = parameters.ResourceIdentifier.Identifier;
 
             if (this.storage.Users.ContainsKey(identifier))
             {
                 if (this.storage.Users.TryGetValue(identifier, out Core2EnterpriseUser user))
                 {
-                    result = user as Resource;
-                    return Task.FromResult(result);
+                    return Task.FromResult(user as Resource);
                 }
             }
 
-            throw new HttpResponseException(HttpStatusCode.NotFound);
+            throw new CustomHttpResponseException(HttpStatusCode.NotFound);
         }
 
-        public override Task UpdateAsync(IPatch patch, string correlationIdentifier)
+        public override Task<Resource> UpdateAsync(IPatch patch, string correlationIdentifier)
         {
             if (null == patch)
             {
@@ -304,17 +364,20 @@ public override Task UpdateAsync(IPatch patch, string correlationIdentifier)
 
             if (null == patch.ResourceIdentifier)
             {
-                throw new ArgumentException(string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidOperation));
+                throw new ArgumentException(string.Format(SystemForCrossDomainIdentityManagementServiceResources
+                    .ExceptionInvalidOperation));
             }
 
             if (string.IsNullOrWhiteSpace(patch.ResourceIdentifier.Identifier))
             {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidOperation);
+                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources
+                    .ExceptionInvalidOperation);
             }
 
             if (null == patch.PatchRequest)
             {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidOperation);
+                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources
+                    .ExceptionInvalidOperation);
             }
 
             PatchRequest2 patchRequest =
@@ -335,10 +398,10 @@ public override Task UpdateAsync(IPatch patch, string correlationIdentifier)
             }
             else
             {
-                throw new HttpResponseException(HttpStatusCode.NotFound);
+                throw new CustomHttpResponseException(HttpStatusCode.NotFound);
             }
 
-            return Task.CompletedTask;
+            return Task.FromResult<Resource>(user);
         }
     }
 }
diff --git a/Microsoft.SCIM.WebHostSample/appsettings.Development.json b/Microsoft.SCIM.WebHostSample/appsettings.Development.json
index 7da2847a..8b8ec055 100644
--- a/Microsoft.SCIM.WebHostSample/appsettings.Development.json
+++ b/Microsoft.SCIM.WebHostSample/appsettings.Development.json
@@ -9,7 +9,7 @@
   "Token": {
     "TokenAudience": "Microsoft.Security.Bearer",
     "TokenIssuer": "Microsoft.Security.Bearer",
-    "IssuerSigningKey": "A1B2C3D4E5F6A1B2C3D4E5F6",
+    "IssuerSigningKey": "A1B2C3D4E5F6A1B2C3D4E5F6G8H9I10J11K12L13M14N15O16P17Q18R19S20T21U22V23W24X25Y26Z",
     "TokenLifetimeInMins": "120"
   }
 }
diff --git a/Microsoft.SCIM.sln b/Microsoft.SCIM.sln
index fff9b0ca..a3069241 100644
--- a/Microsoft.SCIM.sln
+++ b/Microsoft.SCIM.sln
@@ -7,6 +7,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.SCIM", "Microsoft
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.SCIM.WebHostSample", "Microsoft.SCIM.WebHostSample\Microsoft.SCIM.WebHostSample.csproj", "{238F1B05-D3EE-4AB4-871E-ADEA0A1665CF}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.SCIM.PlaywrightTests", "Microsoft.SCIM.PlaywrightTests\Microsoft.SCIM.PlaywrightTests.csproj", "{48A8DD7E-0D51-4CB4-B889-8D0A7CC2645D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -21,6 +23,10 @@ Global
 		{238F1B05-D3EE-4AB4-871E-ADEA0A1665CF}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{238F1B05-D3EE-4AB4-871E-ADEA0A1665CF}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{238F1B05-D3EE-4AB4-871E-ADEA0A1665CF}.Release|Any CPU.Build.0 = Release|Any CPU
+		{48A8DD7E-0D51-4CB4-B889-8D0A7CC2645D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{48A8DD7E-0D51-4CB4-B889-8D0A7CC2645D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{48A8DD7E-0D51-4CB4-B889-8D0A7CC2645D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{48A8DD7E-0D51-4CB4-B889-8D0A7CC2645D}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Microsoft.SCIM.csproj b/Microsoft.SystemForCrossDomainIdentityManagement/Microsoft.SCIM.csproj
index aac203c9..ec39f66e 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Microsoft.SCIM.csproj
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Microsoft.SCIM.csproj
@@ -1,24 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <NeutralLanguage>en</NeutralLanguage>
+    <AnalysisMode>AllEnabledByDefault</AnalysisMode>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Json.Net" Version="1.0.18" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.1" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="3.1.1" />
-    <PackageReference Include="System.Configuration.ConfigurationManager" Version="4.7.0" />
-    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="5.6.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="3.1.18" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="8.0.1" />
+    <PackageReference Include="System.Configuration.ConfigurationManager" Version="8.0.0" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="7.5.2" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="8.0.5" />
 
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="3.1.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Identity.UI" Version="3.1.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.WebApiCompatShim" Version="2.2.0" />
-    <PackageReference Include="Microsoft.AspNetCore.Server.Kestrel" Version="2.2.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="8.0.5" />
 
-    <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers" Version="2.9.8">
+    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="8.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/DictionaryExtension.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/DictionaryExtension.cs
deleted file mode 100644
index 05d1975d..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/DictionaryExtension.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-    using System.Linq;
-
-    internal static class DictionaryExtension
-    {
-        public static void Trim(this IDictionary<string, object> dictionary)
-        {
-            IReadOnlyCollection<string> keys = dictionary.Keys.ToArray();
-            foreach (string key in keys)
-            {
-                object value = dictionary[key];
-                if (null == value)
-                {
-                    dictionary.Remove(key);
-                }
-
-                IDictionary<string, object> dictionaryValue = value as IDictionary<string, object>;
-                if (dictionaryValue != null)
-                {
-                    dictionaryValue.Trim();
-                    if (dictionaryValue.Count <= 0)
-                    {
-                        dictionary.Remove(key);
-                    }
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ErrorResponseJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ErrorResponseJsonDeserializingFactory.cs
deleted file mode 100644
index 1d9c7e4c..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ErrorResponseJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public sealed class ErrorResponseJsonDeserializingFactory :
-        ProtocolJsonDeserializingFactory<ErrorResponse>
-    {
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/Extension.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/Extension.cs
deleted file mode 100644
index 7a069967..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/Extension.cs
+++ /dev/null
@@ -1,92 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Net.Http;
-
-    public abstract class Extension : IExtension
-    {
-        private const string ArgumentNameController = "controller";
-        private const string ArgumentNameJsonDeserializingFactory = "jsonDeserializingFactory";
-        private const string ArgumentNamePath = "path";
-        private const string ArgumentNameSchemaIdentifier = "schemaIdentifier";
-        private const string ArgumentNameTypeName = "typeName";
-
-        protected Extension(
-            string schemaIdentifier,
-            string typeName,
-            string path,
-            Type controller,
-            JsonDeserializingFactory jsonDeserializingFactory)
-        {
-            if (string.IsNullOrWhiteSpace(schemaIdentifier))
-            {
-                throw new ArgumentNullException(Extension.ArgumentNameSchemaIdentifier);
-            }
-
-            if (string.IsNullOrWhiteSpace(typeName))
-            {
-                throw new ArgumentNullException(Extension.ArgumentNameTypeName);
-            }
-
-            if (string.IsNullOrWhiteSpace(path))
-            {
-                throw new ArgumentNullException(Extension.ArgumentNamePath);
-            }
-
-            this.SchemaIdentifier = schemaIdentifier;
-            this.TypeName = typeName;
-            this.Path = path;
-            this.Controller = controller ?? throw new ArgumentNullException(Extension.ArgumentNameController);
-            this.JsonDeserializingFactory = jsonDeserializingFactory ?? throw new ArgumentNullException(Extension.ArgumentNameJsonDeserializingFactory);
-        }
-
-        public Type Controller
-        {
-            get;
-            private set;
-        }
-
-        public JsonDeserializingFactory JsonDeserializingFactory
-        {
-            get;
-            private set;
-        }
-
-        public string Path
-        {
-            get;
-            private set;
-        }
-
-        public string SchemaIdentifier
-        {
-            get;
-            private set;
-        }
-
-        public string TypeName
-        {
-            get;
-            private set;
-        }
-
-        public virtual bool Supports(HttpRequestMessage request)
-        {
-            if (request == null)
-            {
-                throw new ArgumentNullException(nameof(request));
-            }
-
-            bool result =
-                request.RequestUri?.AbsolutePath?.EndsWith(
-                       this.Path,
-                       StringComparison.OrdinalIgnoreCase) == true;
-
-            return result;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/Filter.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/Filter.cs
index 1e19a17e..e7c153e1 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/Filter.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/Filter.cs
@@ -91,6 +91,7 @@ private enum ComparisonOperatorValue
             co,
             sw,
             ew,
+            pr,
             ge,
             gt,
             includes,
@@ -200,9 +201,15 @@ public string Serialize()
                 case ComparisonOperator.BitAnd:
                     operatorValue = ComparisonOperatorValue.bitAnd;
                     break;
+                case ComparisonOperator.StartsWith:
+                    operatorValue = ComparisonOperatorValue.sw;
+                    break;
                 case ComparisonOperator.EndsWith:
                     operatorValue = ComparisonOperatorValue.ew;
                     break;
+                case ComparisonOperator.Present:
+                    operatorValue = ComparisonOperatorValue.pr;
+                    break;
                 case ComparisonOperator.Equals:
                     operatorValue = ComparisonOperatorValue.eq;
                     break;
@@ -218,6 +225,9 @@ public string Serialize()
                 case ComparisonOperator.LessThan:
                     operatorValue = ComparisonOperatorValue.lt;
                     break;
+                case ComparisonOperator.Contains:
+                    operatorValue = ComparisonOperatorValue.co;
+                    break;
                 case ComparisonOperator.Includes:
                     operatorValue = ComparisonOperatorValue.includes;
                     break;
@@ -238,7 +248,8 @@ public string Serialize()
                     break;
                 default:
                     string notSupportedValue = Enum.GetName(typeof(ComparisonOperator), this.FilterOperator);
-                    throw new NotSupportedException(notSupportedValue);
+
+                    throw new ScimTypeException(ErrorType.invalidFilter, string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterOperatorNotSupportedTemplate, notSupportedValue));
             }
 
             string rightHandSide;
@@ -305,7 +316,7 @@ public static string ToString(IReadOnlyCollection<IFilter> filters)
                 Filter clone = new Filter(filter);
                 clone.ComparisonValue = placeholder;
                 string currentFilter = clone.Serialize();
-                string encodedFilter = 
+                string encodedFilter =
                     HttpUtility
                     .UrlEncode(currentFilter)
                     .Replace(placeholder, filter.ComparisonValueEncoded, StringComparison.InvariantCulture);
@@ -414,4 +425,4 @@ private static void Validate(AttributeDataType? dataType, string value)
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/FilterExpression.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/FilterExpression.cs
index c01c685b..256e489c 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/FilterExpression.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/FilterExpression.cs
@@ -185,6 +185,7 @@ private enum ComparisonOperatorValue
             co,
             sw,
             ew,
+            pr,
             ge,
             gt,
             includes,
@@ -271,9 +272,15 @@ private ComparisonOperatorValue Operator
                     case ComparisonOperatorValue.bitAnd:
                         this.filterOperator = ComparisonOperator.BitAnd;
                         break;
+                    case ComparisonOperatorValue.sw:
+                        this.filterOperator = ComparisonOperator.StartsWith;
+                        break;
                     case ComparisonOperatorValue.ew:
                         this.filterOperator = ComparisonOperator.EndsWith;
                         break;
+                    case ComparisonOperatorValue.pr:
+                        this.filterOperator = ComparisonOperator.Present;
+                        break;
                     case ComparisonOperatorValue.eq:
                         this.filterOperator = ComparisonOperator.Equals;
                         break;
@@ -289,6 +296,9 @@ private ComparisonOperatorValue Operator
                     case ComparisonOperatorValue.lt:
                         this.filterOperator = ComparisonOperator.LessThan;
                         break;
+                    case ComparisonOperatorValue.co:
+                        this.filterOperator = ComparisonOperator.Contains;
+                        break;
                     case ComparisonOperatorValue.includes:
                         this.filterOperator = ComparisonOperator.Includes;
                         break;
@@ -309,7 +319,7 @@ private ComparisonOperatorValue Operator
                         break;
                     default:
                         string notSupported = Enum.GetName(typeof(ComparisonOperatorValue), this.Operator);
-                        throw new NotSupportedException(notSupported);
+                        throw new ScimTypeException(ErrorType.invalidFilter,string.Format(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterOperatorNotSupportedTemplate, notSupported));
                 }
                 this.comparisonOperator = value;
             }
@@ -842,4 +852,4 @@ public override string ToString()
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/IGroupDeserializer.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/IGroupDeserializer.cs
deleted file mode 100644
index e7480cc0..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/IGroupDeserializer.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Deserializer", Justification = "False analysis")]
-    public interface IGroupDeserializer
-    {
-        IResourceJsonDeserializingFactory<GroupBase> GroupDeserializationBehavior { get; set; }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/IPatchRequest2Deserializer.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/IPatchRequest2Deserializer.cs
deleted file mode 100644
index b585026f..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/IPatchRequest2Deserializer.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Deserializer", Justification = "False analysis")]
-    public interface IPatchRequest2Deserializer
-    {
-        ISchematizedJsonDeserializingFactory<PatchRequest2> PatchRequest2DeserializationBehavior { get; set; }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ISchematizedJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ISchematizedJsonDeserializingFactory.cs
deleted file mode 100644
index 3ca37ea3..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ISchematizedJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    internal interface ISchematizedJsonDeserializingFactory :
-        IGroupDeserializer,
-        IPatchRequest2Deserializer,
-        IUserDeserializer
-    {
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/IUserDeserializer.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/IUserDeserializer.cs
deleted file mode 100644
index e8648363..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/IUserDeserializer.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Deserializer", Justification = "False analysis")]
-    public interface IUserDeserializer
-    {
-        IResourceJsonDeserializingFactory<Core2UserBase> UserDeserializationBehavior { get; set; }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/MediaTypes.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/MediaTypes.cs
deleted file mode 100644
index 8a83cd45..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/MediaTypes.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public static class MediaTypes
-    {
-        public const string JavaWebToken = "application/jwt";
-        public const string Json = "application/json";
-        public const string Protocol = ProtocolConstants.ContentType;
-        public const string Stream = "application/octet-stream";
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchOperation2Combined.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchOperation2Combined.cs
index a893293e..a9ec282e 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchOperation2Combined.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchOperation2Combined.cs
@@ -5,7 +5,6 @@
 namespace Microsoft.SCIM
 {
     using System;
-    using System.Collections.Generic;
     using System.Globalization;
     using System.Linq;
     using System.Runtime.Serialization;
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchOperation2SingleValuedJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchOperation2SingleValuedJsonDeserializingFactory.cs
deleted file mode 100644
index 29c1fa08..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchOperation2SingleValuedJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-namespace Microsoft.SCIM
-{
-    internal class PatchOperation2SingleValuedJsonDeserializingFactory :
-        ProtocolJsonDeserializingFactory<PatchOperation2SingleValued>
-    {
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchOperationJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchOperationJsonDeserializingFactory.cs
deleted file mode 100644
index 7f0d0c3e..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchOperationJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    internal class PatchOperation2JsonDeserializingFactory : ProtocolJsonDeserializingFactory<PatchOperation2Combined>
-    {
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchRequest2.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchRequest2.cs
index 88b8bc1d..e6a21588 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchRequest2.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchRequest2.cs
@@ -4,7 +4,6 @@
 
 namespace Microsoft.SCIM
 {
-    using System;
     using System.Collections.Generic;
     using System.Runtime.Serialization;
 
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchRequest2DeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchRequest2DeserializingFactory.cs
deleted file mode 100644
index ba0129d8..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchRequest2DeserializingFactory.cs
+++ /dev/null
@@ -1,133 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Linq;
-
-    public abstract class PatchRequest2DeserializingFactory<TPatchRequest, TOperation> :
-        ProtocolJsonDeserializingFactory<TPatchRequest>,
-        ISchematizedJsonDeserializingFactory<TPatchRequest>
-        where TOperation : PatchOperation2Base
-        where TPatchRequest : PatchRequest2Base<TOperation>
-    {
-        public override TPatchRequest Create(IReadOnlyDictionary<string, object> json)
-        {
-            Dictionary<string, object> normalized =
-                this.Normalize(json)
-                .ToDictionary(
-                    (KeyValuePair<string, object> item) => item.Key,
-                    (KeyValuePair<string, object> item) => item.Value);
-            if (normalized.TryGetValue(ProtocolAttributeNames.Operations, out object operations))
-            {
-                normalized.Remove(ProtocolAttributeNames.Operations);
-            }
-            TPatchRequest result = base.Create(normalized);
-            if (operations != null)
-            {
-                IReadOnlyCollection<PatchOperation2Base> patchOperations =
-                    PatchRequest2DeserializingFactory<TPatchRequest, TOperation>.Deserialize(operations);
-                foreach (PatchOperation2Base patchOperation in patchOperations)
-                {
-                    result.AddOperation(patchOperation as TOperation);
-                }
-            }
-            return result;
-        }
-
-        private static bool TryDeserialize(Dictionary<string, object> json, out PatchOperation2Base operation)
-        {
-            operation = null;
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            if (!json.TryGetValue(AttributeNames.Value, out object value))
-            {
-                return false;
-            }
-
-            switch (value)
-            {
-                case string scalar:
-                    operation = new PatchOperation2SingleValuedJsonDeserializingFactory().Create(json);
-                    return true;
-                case ArrayList _:
-                case object _:
-                    operation = new PatchOperation2JsonDeserializingFactory().Create(json);
-                    return true;
-                default:
-                    string unsupported = value.GetType().FullName;
-                    throw new NotSupportedException(unsupported);
-            }
-        }
-
-        private static IReadOnlyCollection<PatchOperation2Base> Deserialize(ArrayList operations)
-        {
-            if (null == operations)
-            {
-                throw new ArgumentNullException(nameof(operations));
-            }
-
-            List<PatchOperation2Base> result = new List<PatchOperation2Base>(operations.Count);
-            foreach (Dictionary<string, object> json in operations)
-            {
-                if
-                (
-                    PatchRequest2DeserializingFactory<TPatchRequest, TOperation>.TryDeserialize(
-                        json,
-                        out PatchOperation2Base patchOperation)
-                )
-                {
-                    result.Add(patchOperation);
-                }
-            }
-            return result;
-        }
-
-        private static IReadOnlyCollection<PatchOperation2Base> Deserialize(object[] operations)
-        {
-            if (null == operations)
-            {
-                throw new ArgumentNullException(nameof(operations));
-            }
-
-            List<PatchOperation2Base> result = new List<PatchOperation2Base>(operations.Length);
-            foreach (Dictionary<string, object> json in operations)
-            {
-                if
-                (
-                    PatchRequest2DeserializingFactory<TPatchRequest, TOperation>.TryDeserialize(
-                        json,
-                        out PatchOperation2Base patchOperation)
-                )
-                {
-                    result.Add(patchOperation);
-                }
-            }
-            return result;
-        }
-
-        private static IReadOnlyCollection<PatchOperation2Base> Deserialize(object operations)
-        {
-            IReadOnlyCollection<PatchOperation2Base> result;
-            switch (operations)
-            {
-                case ArrayList list:
-                    result = PatchRequest2DeserializingFactory<TPatchRequest, TOperation>.Deserialize(list);
-                    return result;
-                case object[] array:
-                    result = PatchRequest2DeserializingFactory<TPatchRequest, TOperation>.Deserialize(array);
-                    return result;
-                default:
-                    string unsupported = operations.GetType().FullName;
-                    throw new NotSupportedException(unsupported);
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchRequest2JsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchRequest2JsonDeserializingFactory.cs
deleted file mode 100644
index 2d5e5bde..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/PatchRequest2JsonDeserializingFactory.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public sealed class PatchRequest2JsonDeserializingFactory :
-        PatchRequest2DeserializingFactory<PatchRequest2, PatchOperation2Combined>
-    {
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ProtocolExtensions.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ProtocolExtensions.cs
index 282cca9b..13e6aa80 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ProtocolExtensions.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ProtocolExtensions.cs
@@ -5,19 +5,11 @@
 namespace Microsoft.SCIM
 {
     using System;
-    using System.Collections;
     using System.Collections.Generic;
-    using System.Globalization;
-    using System.IO;
     using System.Linq;
     using System.Net.Http;
-    using System.Net.Http.Formatting;
-    using System.Text;
     using System.Text.RegularExpressions;
-    using System.Threading.Tasks;
-    using System.Web;
     using Newtonsoft.Json;
-    using Newtonsoft.Json.Linq;
 
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "None")]
     public static class ProtocolExtensions
@@ -40,9 +32,6 @@ public static class ProtocolExtensions
                     new Regex(ProtocolExtensions.BulkIdentifierPattern, RegexOptions.IgnoreCase | RegexOptions.Compiled));
         private interface IHttpRequestMessageWriter : IDisposable
         {
-            void Close();
-            Task FlushAsync();
-            Task WriteAsync();
         }
 
         public static HttpMethod PatchMethod
@@ -220,35 +209,6 @@ private static void Apply(this Core2Group group, PatchOperation2 operation)
             }
         }
 
-        public static HttpRequestMessage ComposeDeleteRequest(this Resource resource, Uri baseResourceIdentifier)
-        {
-            if (null == baseResourceIdentifier)
-            {
-                throw new ArgumentNullException(nameof(baseResourceIdentifier));
-            }
-
-            Uri resourceIdentifier = resource.GetResourceIdentifier(baseResourceIdentifier);
-
-            HttpRequestMessage result = null;
-            try
-            {
-                result = new HttpRequestMessage(HttpMethod.Delete, resourceIdentifier);
-                return result;
-            }
-            catch
-            {
-                if (result != null)
-                {
-                    result.Dispose();
-#pragma warning disable IDE0059 // Unnecessary assignment of a value
-                    result = null;
-#pragma warning restore IDE0059 // Unnecessary assignment of a value
-                }
-
-                throw;
-            }
-        }
-
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "False analysis of 'this' parameter of an extension method")]
         public static HttpRequestMessage ComposeGetRequest(
             this Schematized schematized,
@@ -305,41 +265,6 @@ public static HttpRequestMessage ComposeGetRequest(
             }
         }
 
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "False analysis of 'this' parameter of an extension method")]
-        public static HttpRequestMessage ComposeGetRequest(
-            this Schematized schematized,
-            Uri baseResourceIdentifier,
-            IReadOnlyCollection<IFilter> filters,
-            IReadOnlyCollection<string> requestedAttributePaths,
-            IReadOnlyCollection<string> excludedAttributePaths)
-        {
-            HttpRequestMessage result = null;
-            try
-            {
-                result =
-                    schematized
-                    .ComposeGetRequest(
-                        baseResourceIdentifier,
-                        filters,
-                        requestedAttributePaths,
-                        excludedAttributePaths,
-                        null);
-                return result;
-            }
-            catch
-            {
-                if (result != null)
-                {
-                    result.Dispose();
-#pragma warning disable IDE0059 // Unnecessary assignment of a value
-                    result = null;
-#pragma warning restore IDE0059 // Unnecessary assignment of a value
-                }
-
-                throw;
-            }
-        }
-
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "False analysis of 'this' parameter of an extension method")]
         public static HttpRequestMessage ComposeGetRequest(
             this Resource resource,
@@ -387,264 +312,6 @@ public static HttpRequestMessage ComposeGetRequest(
             }
         }
 
-        public static HttpRequestMessage ComposeGetRequest(this Resource resource, Uri baseResourceIdentifier)
-        {
-            if (null == baseResourceIdentifier)
-            {
-                throw new ArgumentNullException(nameof(baseResourceIdentifier));
-            }
-
-            HttpRequestMessage result = null;
-            try
-            {
-                IReadOnlyCollection<string> requestedAttributePaths = Array.Empty<string>();
-                IReadOnlyCollection<string> excludedAttributePaths = Array.Empty<string>();
-                result = resource.ComposeGetRequest(baseResourceIdentifier, requestedAttributePaths, excludedAttributePaths);
-                return result;
-            }
-            catch
-            {
-                if (result != null)
-                {
-                    result.Dispose();
-#pragma warning disable IDE0059 // Unnecessary assignment of a value
-                    result = null;
-#pragma warning restore IDE0059 // Unnecessary assignment of a value
-                }
-
-                throw;
-            }
-        }
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "The parameter must be a patch for the operation to produce a semantically valid result")]
-        public static HttpRequestMessage ComposePatchRequest(
-            this Resource resource,
-            Uri baseResourceIdentifier,
-            PatchRequestBase patch)
-        {
-            if (null == baseResourceIdentifier)
-            {
-                throw new ArgumentNullException(nameof(baseResourceIdentifier));
-            }
-
-            if (null == patch)
-            {
-                throw new ArgumentNullException(nameof(patch));
-            }
-
-            Dictionary<string, object> json = patch.ToJson();
-
-            Uri resourceIdentifier = resource.GetResourceIdentifier(baseResourceIdentifier);
-
-            HttpRequestMessage result = null;
-            try
-            {
-                HttpContent requestContent = null;
-                try
-                {
-                    string contentType = MediaTypes.Protocol;
-
-                    MediaTypeFormatter contentFormatter = new JsonMediaTypeFormatter();
-                    requestContent =
-                        new ObjectContent<Dictionary<string, object>>(
-                            json,
-                            contentFormatter,
-                            contentType);
-                    result = new HttpRequestMessage(ProtocolExtensions.PatchMethod, resourceIdentifier);
-                    result.Content = requestContent;
-                    requestContent = null;
-                    return result;
-                }
-                finally
-                {
-                    if (requestContent != null)
-                    {
-                        requestContent.Dispose();
-                        requestContent = null;
-                    }
-                }
-            }
-            catch
-            {
-                if (result != null)
-                {
-                    result.Dispose();
-#pragma warning disable IDE0059 // Unnecessary assignment of a value
-                    result = null;
-#pragma warning restore IDE0059 // Unnecessary assignment of a value
-                }
-
-                throw;
-            }
-        }
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "False analysis of 'this' parameter of an extension method")]
-        public static HttpRequestMessage ComposePatchRequest(
-            this Resource patch,
-            Uri baseResourceIdentifier)
-        {
-            if (null == baseResourceIdentifier)
-            {
-                throw new ArgumentNullException(nameof(baseResourceIdentifier));
-            }
-
-            Dictionary<string, object> json = patch.ToJson();
-            json.Trim();
-
-            Uri resourceIdentifier = patch.GetResourceIdentifier(baseResourceIdentifier);
-
-            HttpRequestMessage result = null;
-            try
-            {
-                HttpContent requestContent = null;
-                try
-                {
-                    MediaTypeFormatter contentFormatter = new JsonMediaTypeFormatter();
-                    requestContent =
-                        new ObjectContent<Dictionary<string, object>>(
-                            json,
-                            contentFormatter,
-                            MediaTypes.Json);
-                    result = new HttpRequestMessage(ProtocolExtensions.PatchMethod, resourceIdentifier);
-                    result.Content = requestContent;
-                    requestContent = null;
-                    return result;
-                }
-                finally
-                {
-                    if (requestContent != null)
-                    {
-                        requestContent.Dispose();
-                        requestContent = null;
-                    }
-                }
-            }
-            catch
-            {
-                if (result != null)
-                {
-                    result.Dispose();
-#pragma warning disable IDE0059 // Unnecessary assignment of a value
-                    result = null;
-#pragma warning restore IDE0059 // Unnecessary assignment of a value
-                }
-
-                throw;
-            }
-        }
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "False analysis of extension method")]
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Performing the operation on the base type would be invalid")]
-        public static HttpRequestMessage ComposePutRequest(this Resource resource, Uri baseResourceIdentifier)
-        {
-            if (null == baseResourceIdentifier)
-            {
-                throw new ArgumentNullException(nameof(baseResourceIdentifier));
-            }
-
-            string contentType = MediaTypes.Protocol;
-
-            Dictionary<string, object> json = resource.ToJson();
-            json.Trim();
-
-            Uri resourceIdentifier = resource.GetResourceIdentifier(baseResourceIdentifier);
-
-            HttpRequestMessage result = null;
-            try
-            {
-                HttpContent requestContent = null;
-                try
-                {
-                    MediaTypeFormatter contentFormatter = new JsonMediaTypeFormatter();
-                    requestContent =
-                        new ObjectContent<Dictionary<string, object>>(
-                            json,
-                            contentFormatter,
-                            contentType);
-                    result = new HttpRequestMessage(HttpMethod.Put, resourceIdentifier);
-                    result.Content = requestContent;
-                    requestContent = null;
-                    return result;
-                }
-                finally
-                {
-                    if (requestContent != null)
-                    {
-                        requestContent.Dispose();
-                        requestContent = null;
-                    }
-                }
-            }
-            catch
-            {
-                if (result != null)
-                {
-                    result.Dispose();
-#pragma warning disable IDE0059 // Unnecessary assignment of a value
-                    result = null;
-#pragma warning restore IDE0059 // Unnecessary assignment of a value
-                }
-
-                throw;
-            }
-        }
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "False analysis of extension method")]
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Performing the operation on the base type would be invalid")]
-        public static HttpRequestMessage ComposePostRequest(this Resource resource, Uri baseResourceIdentifier)
-        {
-            if (null == baseResourceIdentifier)
-            {
-                throw new ArgumentNullException(nameof(baseResourceIdentifier));
-            }
-
-            string contentType = MediaTypes.Protocol;
-
-            Dictionary<string, object> json = resource.ToJson();
-            json.Trim();
-
-            Uri typeResourceIdentifier = resource.GetTypeIdentifier(baseResourceIdentifier);
-
-            HttpRequestMessage result = null;
-            try
-            {
-                HttpContent requestContent = null;
-                try
-                {
-                    MediaTypeFormatter contentFormatter = new JsonMediaTypeFormatter();
-                    requestContent =
-                        new ObjectContent<Dictionary<string, object>>(
-                            json,
-                            contentFormatter,
-                            contentType);
-                    result = new HttpRequestMessage(HttpMethod.Post, typeResourceIdentifier);
-                    result.Content = requestContent;
-                    requestContent = null;
-                    return result;
-                }
-                finally
-                {
-                    if (requestContent != null)
-                    {
-                        requestContent.Dispose();
-                        requestContent = null;
-                    }
-                }
-            }
-            catch
-            {
-                if (result != null)
-                {
-                    result.Dispose();
-#pragma warning disable IDE0059 // Unnecessary assignment of a value
-                    result = null;
-#pragma warning restore IDE0059 // Unnecessary assignment of a value
-                }
-
-                throw;
-            }
-        }
-
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "False analysis of 'this' parameter of an extension method")]
         public static UriBuilder ComposeResourceIdentifier(this Resource resource, Uri baseResourceIdentifier)
         {
@@ -823,18 +490,6 @@ private static Uri ComposeTypeIdentifier(Uri baseResourceIdentifier, string path
             return result;
         }
 
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "False analysis of 'this' parameter of an extension method")]
-        public static IResourceIdentifier GetIdentifier(this Resource resource)
-        {
-            if (!resource.TryGetSchemaIdentifier(out string schemaIdentifier))
-            {
-                schemaIdentifier = resource.GetSchemaIdentifier();
-            }
-
-            IResourceIdentifier result = new ResourceIdentifier(schemaIdentifier, resource.Identifier);
-            return result;
-        }
-
         private static string GetPath(this Schematized schematized)
         {
             if (schematized.TryGetPath(out string path))
@@ -891,7 +546,7 @@ public static Uri GetResourceIdentifier(this Resource resource, Uri baseResource
             string escapedIdentifier = Uri.EscapeDataString(resource.Identifier);
             string resultValue =
                 typeResource.ToString() +
-                ServiceConstants.SeparatorSegments + 
+                ServiceConstants.SeparatorSegments +
                 escapedIdentifier;
             result = new Uri(resultValue);
             return result;
@@ -1227,126 +882,6 @@ internal static IEnumerable<Role> PatchRoles(IEnumerable<Role> roles, PatchOpera
             return result;
         }
 
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "resourceIdentifier", Justification = "False analysis of extension method")]
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "False analysis of 'this' parameter of an extension method")]
-#pragma warning disable IDE0060 // Remove unused parameter
-        public static Uri Serialize(this IResourceIdentifier resourceIdentifier, Resource resource, Uri baseResourceIdentifier)
-#pragma warning restore IDE0060 // Remove unused parameter
-        {
-            if (null == resource)
-            {
-                throw new ArgumentNullException(nameof(resource));
-            }
-
-            if (null == baseResourceIdentifier)
-            {
-                throw new ArgumentNullException(nameof(baseResourceIdentifier));
-            }
-
-            Uri typeResource = resource.GetTypeIdentifier(baseResourceIdentifier);
-            string escapedIdentifier = Uri.EscapeDataString(resource.Identifier);
-            string resultValue =
-                typeResource.ToString() +
-                ServiceConstants.SeparatorSegments +
-                escapedIdentifier;
-
-            Uri result = new Uri(resultValue);
-            return result;
-        }
-
-        public static async Task<string> SerializeAsync(this HttpRequestMessage request, bool acceptLargeObjects)
-        {
-            if (null == request)
-            {
-                throw new ArgumentNullException(nameof(request));
-            }
-
-            StringBuilder buffer = new StringBuilder();
-            TextWriter textWriter = null;
-            try
-            {
-
-#pragma warning disable CA2000 // Dispose objects before losing scope
-                textWriter = new StringWriter(buffer);
-#pragma warning restore CA2000 // Dispose objects before losing scope
-
-                IHttpRequestMessageWriter requestWriter = null;
-                try
-                {
-                    requestWriter = new HttpRequestMessageWriter(request, textWriter, acceptLargeObjects);
-                    textWriter = null;
-                    await requestWriter.WriteAsync().ConfigureAwait(false);
-                    await requestWriter.FlushAsync().ConfigureAwait(false);
-                    string result = buffer.ToString();
-                    return result;
-                }
-                finally
-                {
-                    if (requestWriter != null)
-                    {
-                        requestWriter.Close();
-                        requestWriter = null;
-                    }
-                }
-            }
-            finally
-            {
-                if (textWriter != null)
-                {
-                    textWriter.Flush();
-                    textWriter.Close();
-#pragma warning disable IDE0059 // Unnecessary assignment of a value
-                    textWriter = null;
-#pragma warning restore IDE0059 // Unnecessary assignment of a value
-                }
-            }
-        }
-
-        public static async Task<string> SerializeAsync(this HttpRequestMessage request)
-        {
-            if (null == request)
-            {
-                throw new ArgumentNullException(nameof(request));
-            }
-
-            string result = await request.SerializeAsync(false).ConfigureAwait(false);
-            return result;
-        }
-
-        public static IReadOnlyCollection<T> ToCollection<T>(this IEnumerable enumerable)
-        {
-            if (null == enumerable)
-            {
-                throw new ArgumentNullException(nameof(enumerable));
-            }
-
-            IList<T> list = new List<T>();
-            foreach (object item in enumerable)
-            {
-                T typed = (T)item;
-                list.Add(typed);
-            }
-            IReadOnlyCollection<T> result = list.ToArray();
-            return result;
-        }
-
-        public static IReadOnlyCollection<T> ToCollection<T>(this ArrayList array)
-        {
-            if (null == array)
-            {
-                throw new ArgumentNullException(nameof(array));
-            }
-
-            IList<T> list = new List<T>(array.Count);
-            foreach (object item in array)
-            {
-                T typed = (T)item;
-                list.Add(typed);
-            }
-            IReadOnlyCollection<T> result = list.ToArray();
-            return result;
-        }
-
         public static IReadOnlyCollection<T> ToCollection<T>(this T item)
         {
             IReadOnlyCollection<T> result =
@@ -1536,105 +1071,5 @@ public static bool TryParseBulkIdentifierReferenceValue(this OperationValue valu
             bool result = ProtocolExtensions.TryParseBulkIdentifierReferenceValue(value.Value, out bulkIdentifier);
             return result;
         }
-
-
-        private sealed class HttpRequestMessageWriter : IHttpRequestMessageWriter
-        {
-            private const string TemplateHeader = "{0}: {1}";
-
-            private readonly object thisLock = new object();
-
-            private TextWriter innerWriter;
-
-            public HttpRequestMessageWriter(HttpRequestMessage message, TextWriter writer, bool acceptLargeObjects)
-            {
-                this.Message = message ?? throw new ArgumentNullException(nameof(message));
-                this.innerWriter = writer ?? throw new ArgumentNullException(nameof(writer));
-                this.AcceptLargeObjects = acceptLargeObjects;
-            }
-
-            private bool AcceptLargeObjects
-            {
-                get;
-            }
-
-            private HttpRequestMessage Message
-            {
-                get;
-                set;
-            }
-
-            public void Close()
-            {
-                this.innerWriter.Flush();
-                this.innerWriter.Close();
-            }
-
-            public void Dispose()
-            {
-                if (this.innerWriter != null)
-                {
-                    lock (this.thisLock)
-                    {
-                        if (this.innerWriter != null)
-                        {
-                            this.Close();
-                            this.innerWriter = null;
-                        }
-                    }
-                }
-            }
-
-            public async Task FlushAsync()
-            {
-                await this.innerWriter.FlushAsync().ConfigureAwait(false);
-            }
-
-            public async Task WriteAsync()
-            {
-                if (this.Message.RequestUri != null)
-                {
-                    string line = HttpUtility.UrlDecode(this.Message.RequestUri.AbsoluteUri);
-                    await this.innerWriter.WriteLineAsync(line).ConfigureAwait(false);
-                }
-
-                if (this.Message.Headers != null)
-                {
-                    foreach (KeyValuePair<string, IEnumerable<string>> header in this.Message.Headers)
-                    {
-                        if (!header.Value.Any())
-                        {
-                            continue;
-                        }
-
-                        string value;
-                        if (1 == header.Value.LongCount())
-                        {
-                            value = header.Value.Single();
-                        }
-                        else
-                        {
-                            string[] values = header.Value.ToArray();
-                            value = JsonFactory.Instance.Create(values, this.AcceptLargeObjects);
-                        }
-
-                        string line =
-                            string.Format(
-                                CultureInfo.InvariantCulture,
-                                HttpRequestMessageWriter.TemplateHeader,
-                                header.Key,
-                                value);
-                        await this.innerWriter.WriteLineAsync(line).ConfigureAwait(false);
-                    }
-                }
-
-                if (this.Message.Content != null)
-                {
-                    string line = await this.Message.Content.ReadAsStringAsync().ConfigureAwait(false);
-                    await this.innerWriter.WriteLineAsync(line).ConfigureAwait(false);
-                }
-            }
-
-        }
     }
 }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ProtocolJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ProtocolJsonDeserializingFactory.cs
deleted file mode 100644
index fee34e2d..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ProtocolJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System.Threading;
-
-    public abstract class ProtocolJsonDeserializingFactory : ProtocolJsonDeserializingFactory<Schematized>
-    {
-    }
-
-    public abstract class ProtocolJsonDeserializingFactory<T> : JsonDeserializingFactory<T>
-    {
-        private IJsonNormalizationBehavior jsonNormalizer;
-
-        public override IJsonNormalizationBehavior JsonNormalizer
-        {
-            get
-            {
-                IJsonNormalizationBehavior result =
-                    LazyInitializer.EnsureInitialized<IJsonNormalizationBehavior>(
-                        ref this.jsonNormalizer,
-                        () =>
-                            new ProtocolJsonNormalizer());
-                return result;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ProtocolJsonNormalizer.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ProtocolJsonNormalizer.cs
deleted file mode 100644
index f9fdc4cb..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/ProtocolJsonNormalizer.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Reflection;
-    using System.Threading;
-
-    public sealed class ProtocolJsonNormalizer : JsonNormalizerTemplate
-    {
-        private IReadOnlyCollection<string> attributeNames;
-
-        public override IReadOnlyCollection<string> AttributeNames
-        {
-            get
-            {
-                IReadOnlyCollection<string> result =
-                    LazyInitializer.EnsureInitialized<IReadOnlyCollection<string>>(
-                        ref this.attributeNames,
-                        ProtocolJsonNormalizer.CollectAttributeNames);
-                return result;
-            }
-        }
-
-        private static IReadOnlyCollection<string> CollectAttributeNames()
-        {
-            Type attributeNamesType = typeof(ProtocolAttributeNames);
-            IReadOnlyCollection<FieldInfo> members = attributeNamesType.GetFields(BindingFlags.Public | BindingFlags.Static);
-            IReadOnlyCollection<string> protocolAttributeNames =
-                members
-                .Select(
-                    (FieldInfo item) =>
-                        item.GetValue(null))
-                .Cast<string>()
-                .ToArray();
-            IReadOnlyCollection<string> result =
-                new JsonNormalizer()
-                .AttributeNames
-                .Union(protocolAttributeNames)
-                .ToArray();
-            return result;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/QueryResponseJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/QueryResponseJsonDeserializingFactory.cs
deleted file mode 100644
index 55ea36df..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/QueryResponseJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Linq;
-
-    public sealed class QueryResponseJsonDeserializingFactory<T> :
-        ProtocolJsonDeserializingFactory<QueryResponse<T>>
-        where T : Resource
-    {
-        public QueryResponseJsonDeserializingFactory(JsonDeserializingFactory<Schematized> jsonDeserializingFactory)
-        {
-            this.JsonDeserializingFactory =
-                jsonDeserializingFactory ?? throw new ArgumentNullException(nameof(jsonDeserializingFactory));
-        }
-
-        private JsonDeserializingFactory<Schematized> JsonDeserializingFactory
-        {
-            get;
-            set;
-        }
-
-        public override QueryResponse<T> Create(IReadOnlyDictionary<string, object> json)
-        {
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            if (!typeof(T).IsAbstract)
-            {
-                QueryResponse<T> result = base.Create(json);
-                return result;
-            }
-            else
-            {
-                IReadOnlyDictionary<string, object> normalizedJson = this.Normalize(json);
-                IReadOnlyDictionary<string, object> metadataJson =
-                    normalizedJson
-                    .Where(
-                        (KeyValuePair<string, object> item) =>
-                            !string.Equals(ProtocolAttributeNames.Resources, item.Key, StringComparison.OrdinalIgnoreCase))
-                    .ToDictionary(
-                        (KeyValuePair<string, object> item) =>
-                            item.Key,
-                        (KeyValuePair<string, object> item) =>
-                            item.Value);
-                QueryResponse<T> result = base.Create(metadataJson);
-                IReadOnlyCollection<KeyValuePair<string, object>> resourcesJson =
-                    normalizedJson
-                    .Where(
-                        (KeyValuePair<string, object> item) =>
-                            string.Equals(ProtocolAttributeNames.Resources, item.Key, StringComparison.OrdinalIgnoreCase))
-                    .ToArray();
-                if (resourcesJson.Any())
-                {
-                    IEnumerable resourcesArray = (IEnumerable)resourcesJson.Single().Value;
-                    List<T> resources = new List<T>(result.TotalResults);
-                    foreach (object element in resourcesArray)
-                    {
-                        IReadOnlyDictionary<string, object> resourceJson = (IReadOnlyDictionary<string, object>)element;
-                        T resource = (T)this.JsonDeserializingFactory.Create(resourceJson);
-                        resources.Add(resource);
-                    }
-                    result.Resources = resources;
-                }
-                return result;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/SchematizedJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/SchematizedJsonDeserializingFactory.cs
deleted file mode 100644
index 68c226cd..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/SchematizedJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,405 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Threading;
-
-    public sealed class SchematizedJsonDeserializingFactory : SchematizedJsonDeserializingFactoryBase
-    {
-        private ISchematizedJsonDeserializingFactory<PatchRequest2> patchSerializer;
-       
-        public override IReadOnlyCollection<IExtension> Extensions
-        {
-            get;
-            set;
-        }
-        public override IResourceJsonDeserializingFactory<GroupBase> GroupDeserializationBehavior
-        {
-            get;
-            set;
-        }
-
-        public override ISchematizedJsonDeserializingFactory<PatchRequest2> PatchRequest2DeserializationBehavior
-        {
-            get
-            {
-                ISchematizedJsonDeserializingFactory<PatchRequest2> result =
-                    LazyInitializer.EnsureInitialized<ISchematizedJsonDeserializingFactory<PatchRequest2>>(
-                        ref this.patchSerializer,
-                        SchematizedJsonDeserializingFactory.InitializePatchSerializer);
-                return result;
-            }
-
-            set
-            {
-                this.patchSerializer = value;
-            }
-        }
-
-        public override IResourceJsonDeserializingFactory<Core2UserBase> UserDeserializationBehavior
-        {
-            get;
-            set;
-        }
-
-        private Resource CreateGroup(
-            IReadOnlyCollection<string> schemaIdentifiers,
-            IReadOnlyDictionary<string, object> json)
-        {
-            if (null == schemaIdentifiers)
-            {
-                throw new ArgumentNullException(nameof(schemaIdentifiers));
-            }
-
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            if (this.GroupDeserializationBehavior != null)
-            {
-                Resource group = this.GroupDeserializationBehavior.Create(json);
-                return group;
-            }
-
-            if (schemaIdentifiers.Count != 1)
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementProtocolResources.ExceptionInvalidResource);
-            }
-
-            Resource result = new Core2GroupJsonDeserializingFactory().Create(json);
-            return result;
-        }
-
-        private Schematized CreatePatchRequest(IReadOnlyDictionary<string, object> json)
-        {
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            if (this.TryCreatePatchRequest2Legacy(json, out Schematized result))
-            {
-                return result;
-            }
-
-            if (SchematizedJsonDeserializingFactory.TryCreatePatchRequest2Compliant(json, out result))
-            {
-                return result;
-            }
-
-            throw new InvalidOperationException(
-                SystemForCrossDomainIdentityManagementProtocolResources.ExceptionInvalidRequest);
-        }
-
-        private Resource CreateUser(
-            IReadOnlyCollection<string> schemaIdentifiers,
-            IReadOnlyDictionary<string, object> json)
-        {
-            if (null == schemaIdentifiers)
-            {
-                throw new ArgumentNullException(nameof(schemaIdentifiers));
-            }
-
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            if (this.UserDeserializationBehavior != null)
-            {
-                Resource result = this.UserDeserializationBehavior.Create(json);
-                return result;
-            }
-
-            if
-            (
-                    schemaIdentifiers
-                    .SingleOrDefault(
-                        (string item) =>
-                            item.Equals(
-                                SchemaIdentifiers.Core2EnterpriseUser,
-                                StringComparison.OrdinalIgnoreCase)) != null
-            )
-            {
-                Resource result = new Core2EnterpriseUserJsonDeserializingFactory().Create(json);
-                return result;
-            }
-            else
-            {
-                if (schemaIdentifiers.Count != 1)
-                {
-                    throw new ArgumentException(SystemForCrossDomainIdentityManagementProtocolResources.ExceptionInvalidResource);
-                }
-
-                Resource result = new Core2UserJsonDeserializingFactory().Create(json);
-                return result;
-            }
-        }
-       
-        public override Schematized Create(IReadOnlyDictionary<string, object> json)
-        {
-            if (null == json)
-            {
-                return null;
-            }
-
-            IReadOnlyDictionary<string, object> normalizedJson = this.Normalize(json);
-            if (!normalizedJson.TryGetValue(AttributeNames.Schemas, out object value))
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementProtocolResources.ExceptionUnidentifiableSchema);
-            }
-
-            IReadOnlyCollection<string> schemaIdentifiers;
-
-            switch (value)
-            {
-                case IEnumerable schemas:
-                    schemaIdentifiers = schemas.ToCollection<string>();
-                    break;
-                default:
-                    throw new ArgumentException(
-                        SystemForCrossDomainIdentityManagementProtocolResources.ExceptionUnidentifiableSchema);
-            }
-
-#pragma warning disable IDE0018 // Inline variable declaration
-            Schematized result;
-#pragma warning restore IDE0018 // Inline variable declaration
-            if (this.TryCreateResourceFrom(normalizedJson, schemaIdentifiers, out result))
-            {
-                return result;
-            }
-
-            if (this.TryCreateProtocolObjectFrom(normalizedJson, schemaIdentifiers, out result))
-            {
-                return result;
-            }
-
-            if (this.TryCreateExtensionObjectFrom(normalizedJson, schemaIdentifiers, out result))
-            {
-                return result;
-            }
-
-            string allSchemaIdentifiers = string.Join(Environment.NewLine, schemaIdentifiers);
-            throw new NotSupportedException(allSchemaIdentifiers);
-        }
-
-        private static ISchematizedJsonDeserializingFactory<PatchRequest2> InitializePatchSerializer()
-        {
-            ISchematizedJsonDeserializingFactory<PatchRequest2> result = new PatchRequest2JsonDeserializingFactory();
-            return result;
-        }
-
-        private bool TryCreateExtensionObjectFrom(
-            IReadOnlyDictionary<string, object> json,
-            IReadOnlyCollection<string> schemaIdentifiers,
-            out Schematized schematized)
-        {
-            schematized = null;
-
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            if (null == schemaIdentifiers)
-            {
-                throw new ArgumentNullException(nameof(schemaIdentifiers));
-            }
-
-            if (null == this.Extensions)
-            {
-                return false;
-            }
-
-            if (this.Extensions.TryMatch(schemaIdentifiers, out IExtension matchingExtension))
-            {
-                schematized = matchingExtension.JsonDeserializingFactory(json);
-                return true;
-            }
-
-            return false;
-        }
-
-        private static bool TryCreatePatchRequest2Compliant(
-            IReadOnlyDictionary<string, object> json,
-            out Schematized schematized)
-        {
-            schematized = null;
-            try
-            {
-                ISchematizedJsonDeserializingFactory<PatchRequest2> deserializer =
-                    new PatchRequest2JsonDeserializingFactory();
-                schematized = deserializer.Create(json);
-            }
-            catch (OutOfMemoryException)
-            {
-                throw;
-            }
-            catch (ThreadAbortException)
-            {
-                throw;
-            }
-            catch (ThreadInterruptedException)
-            {
-                throw;
-            }
-            catch (StackOverflowException)
-            {
-                throw;
-            }
-#pragma warning disable CA1031 // Do not catch general exception types
-            catch
-            {
-                return false;
-            }
-#pragma warning restore CA1031 // Do not catch general exception types
-
-            return true;
-        }
-
-        private bool TryCreatePatchRequest2Legacy(
-            IReadOnlyDictionary<string, object> json,
-            out Schematized schematized)
-        {
-            schematized = null;
-            try
-            {
-                ISchematizedJsonDeserializingFactory<PatchRequest2> deserializer =
-                    this.PatchRequest2DeserializationBehavior ?? new PatchRequest2JsonDeserializingFactory();
-                schematized = deserializer.Create(json);
-            }
-            catch (OutOfMemoryException)
-            {
-                throw;
-            }
-            catch (ThreadAbortException)
-            {
-                throw;
-            }
-            catch (ThreadInterruptedException)
-            {
-                throw;
-            }
-            catch (StackOverflowException)
-            {
-                throw;
-            }
-#pragma warning disable CA1031 // Do not catch general exception types
-            catch
-            {
-                return false;
-            }
-#pragma warning restore CA1031 // Do not catch general exception types
-
-            return true;
-        }
-
-        private bool TryCreateProtocolObjectFrom(
-            IReadOnlyDictionary<string, object> json,
-            IReadOnlyCollection<string> schemaIdentifiers,
-            out Schematized schematized)
-        {
-            schematized = null;
-
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            if (null == schemaIdentifiers)
-            {
-                throw new ArgumentNullException(nameof(schemaIdentifiers));
-            }
-
-            if (schemaIdentifiers.Count != 1)
-            {
-                return false;
-            }
-
-            if
-            (
-                schemaIdentifiers
-                .SingleOrDefault(
-                    (string item) =>
-                        item.Equals(
-                            ProtocolSchemaIdentifiers.Version2PatchOperation,
-                            StringComparison.OrdinalIgnoreCase)) != null
-            )
-            {
-                schematized = this.CreatePatchRequest(json);
-                return true;
-            }
-
-            if
-            (
-                schemaIdentifiers
-                .SingleOrDefault(
-                    (string item) =>
-                        item.Equals(
-                            ProtocolSchemaIdentifiers.Version2Error,
-                            StringComparison.OrdinalIgnoreCase)) != null
-            )
-            {
-                schematized = new ErrorResponseJsonDeserializingFactory().Create(json);
-                return true;
-            }
-
-            return false;
-        }
-
-        private bool TryCreateResourceFrom(
-            IReadOnlyDictionary<string, object> json,
-            IReadOnlyCollection<string> schemaIdentifiers,
-            out Schematized schematized)
-        {
-            schematized = null;
-
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            if (null == schemaIdentifiers)
-            {
-                throw new ArgumentNullException(nameof(schemaIdentifiers));
-            }
-
-            if
-            (
-                schemaIdentifiers
-                .SingleOrDefault(
-                    (string item) =>
-                        item.Equals(
-                            SchemaIdentifiers.Core2User,
-                            StringComparison.OrdinalIgnoreCase)) != null
-            )
-            {
-                schematized = this.CreateUser(schemaIdentifiers, json);
-                return true;
-            }
-
-            if
-            (
-                schemaIdentifiers
-                .SingleOrDefault(
-                    (string item) =>
-                        item.Equals(
-                            SchemaIdentifiers.Core2Group,
-                            StringComparison.OrdinalIgnoreCase)) != null
-            )
-            {
-                schematized = this.CreateGroup(schemaIdentifiers, json);
-                return true;
-            }
-
-            return false;
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/SchematizedJsonDeserializingFactoryBase.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/SchematizedJsonDeserializingFactoryBase.cs
deleted file mode 100644
index 1a3505b8..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/SchematizedJsonDeserializingFactoryBase.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-
-    public abstract class SchematizedJsonDeserializingFactoryBase :
-        ProtocolJsonDeserializingFactory,
-        ISchematizedJsonDeserializingFactory
-    {
-        public abstract IReadOnlyCollection<IExtension> Extensions { get; set; }
-        public abstract IResourceJsonDeserializingFactory<GroupBase> GroupDeserializationBehavior { get; set; }
-        public abstract ISchematizedJsonDeserializingFactory<PatchRequest2> PatchRequest2DeserializationBehavior { get; set; }
-        public abstract IResourceJsonDeserializingFactory<Core2UserBase> UserDeserializationBehavior { get; set; }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/SortOrder.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/SortOrder.cs
deleted file mode 100644
index ce89495e..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Protocol/SortOrder.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public enum SortOrder
-    {
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ascending", Justification = "The casing is as specified by a protocol")]
-        ascending = 0,
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "descending", Justification = "The casing is as specified by a protocol")]
-        descending = 1
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/ComparisonOperator.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/ComparisonOperator.cs
index ff2a993a..92e71eff 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/ComparisonOperator.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/ComparisonOperator.cs
@@ -7,17 +7,20 @@ namespace Microsoft.SCIM
     public enum ComparisonOperator
     {
         BitAnd,
+        StartsWith,
         EndsWith,
         Equals,
         EqualOrGreaterThan,
         GreaterThan,
         EqualOrLessThan,
         LessThan,
+        Contains,
         Includes,
         IsMemberOf,
         MatchesExpression,
         NotBitAnd,
         NotEquals,
-        NotMatchesExpression
+        NotMatchesExpression,
+        Present
     }
-}
\ No newline at end of file
+}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2EnterpriseUserJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2EnterpriseUserJsonDeserializingFactory.cs
deleted file mode 100644
index 57f0f57f..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2EnterpriseUserJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,92 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-
-    public sealed class Core2EnterpriseUserJsonDeserializingFactory :
-        JsonDeserializingFactory<Core2EnterpriseUser>
-    {
-        private static readonly Lazy<JsonDeserializingFactory<Manager>> ManagerFactory =
-            new Lazy<JsonDeserializingFactory<Manager>>(
-                () =>
-                    new ManagerDeserializingFactory());
-
-        public override Core2EnterpriseUser Create(IReadOnlyDictionary<string, object> json)
-        {
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            Manager manager;
-            IReadOnlyDictionary<string, object> normalizedJson = this.Normalize(json);
-            IReadOnlyDictionary<string, object> safeJson;
-            if (normalizedJson.TryGetValue(AttributeNames.Manager, out object managerData)
-                && managerData != null)
-            {
-                safeJson =
-                    normalizedJson
-                    .Where(
-                        (KeyValuePair<string, object> item) =>
-                            !string.Equals(AttributeNames.Manager, item.Key, StringComparison.OrdinalIgnoreCase))
-                    .ToDictionary(
-                        (KeyValuePair<string, object> item) =>
-                            item.Key,
-                        (KeyValuePair<string, object> item) =>
-                            item.Value);
-                switch (managerData)
-                {
-                    case string value:
-                        manager =
-                            new Manager()
-                            {
-                                Value = value
-                            };
-                        break;
-                    case Dictionary<string, object> managerJson:
-                        manager = Core2EnterpriseUserJsonDeserializingFactory.ManagerFactory.Value.Create(managerJson);
-                        break;
-                    default:
-                        throw new NotSupportedException(managerData.GetType().FullName);
-                }
-            }
-            else
-            {
-                safeJson =
-                    normalizedJson
-                    .ToDictionary(
-                        (KeyValuePair<string, object> item) =>
-                            item.Key,
-                        (KeyValuePair<string, object> item) =>
-                            item.Value);
-                manager = null;
-            }
-
-            Core2EnterpriseUser result = base.Create(safeJson);
-
-            foreach (KeyValuePair<string, object> entry in json)
-            {
-                if
-                (
-                        entry.Key.StartsWith(SchemaIdentifiers.PrefixExtension, StringComparison.OrdinalIgnoreCase)
-                    && !entry.Key.StartsWith(SchemaIdentifiers.Core2EnterpriseUser, StringComparison.OrdinalIgnoreCase)
-                    && entry.Value is Dictionary<string, object> nestedObject
-                )
-                {
-                    result.AddCustomAttribute(entry.Key, nestedObject);
-                }
-            }
-
-            return result;
-        }
-
-        private class ManagerDeserializingFactory : JsonDeserializingFactory<Manager>
-        {
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2GroupJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2GroupJsonDeserializingFactory.cs
deleted file mode 100644
index 1cb6a107..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2GroupJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,36 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-
-    public sealed class Core2GroupJsonDeserializingFactory : JsonDeserializingFactory<Core2Group>
-    {
-        public override Core2Group Create(IReadOnlyDictionary<string, object> json)
-        {
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            Core2Group result = base.Create(json);
-
-            foreach (KeyValuePair<string, object> entry in json)
-            {
-                if
-                (
-                        entry.Key.StartsWith(SchemaIdentifiers.PrefixExtension, StringComparison.OrdinalIgnoreCase)
-                    && entry.Value is Dictionary<string, object> nestedObject
-                )
-                {
-                    result.AddCustomAttribute(entry.Key, nestedObject);
-                }
-            }
-
-            return result;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2ResourceTypeJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2ResourceTypeJsonDeserializingFactory.cs
deleted file mode 100644
index 8e8f564d..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2ResourceTypeJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public sealed class Core2ResourceTypeJsonDeserializingFactory :
-        JsonDeserializingFactory<Core2ResourceType>
-    {
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2ServiceConfigurationJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2ServiceConfigurationJsonDeserializingFactory.cs
deleted file mode 100644
index ed297500..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2ServiceConfigurationJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public sealed class Core2ServiceConfigurationJsonDeserializingFactory :
-        JsonDeserializingFactory<Core2ServiceConfiguration>
-    {
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2UserJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2UserJsonDeserializingFactory.cs
deleted file mode 100644
index 5d5d77a5..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Core2UserJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public sealed class Core2UserJsonDeserializingFactory : JsonDeserializingFactory<Core2User>
-    {
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/DateTimeExtension.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/DateTimeExtension.cs
deleted file mode 100644
index 2389d9cb..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/DateTimeExtension.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Globalization;
-
-    internal static class DateTimeExtension
-    {
-        private const string FormatStringRoundtrip = "O";
-
-        public static string ToRoundtripString(this DateTime dateTime)
-        {
-            string result = dateTime.ToString(DateTimeExtension.FormatStringRoundtrip, CultureInfo.InvariantCulture);
-            return result;
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EnumerableExtension.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EnumerableExtension.cs
deleted file mode 100644
index 058b91fa..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EnumerableExtension.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-
-    internal static class EnumerableExtension
-    {
-        public static int CheckedCount<T>(this IEnumerable<T> enumeration)
-        {
-            long longCount = enumeration.LongCount();
-            int result = Convert.ToInt32(longCount);
-            return result;
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventToken.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventToken.cs
deleted file mode 100644
index f59a62d3..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventToken.cs
+++ /dev/null
@@ -1,466 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.IdentityModel.Tokens.Jwt;
-    using System.Linq;
-    using Microsoft.IdentityModel.Tokens;
-
-    // Implements https://tools.ietf.org/html/draft-ietf-secevent-token
-    public class EventToken : IEventToken
-    {
-        public const string HeaderKeyAlgorithm = "alg";
-        public const string JwtAlgorithmNone = "none";
-
-        private static readonly Lazy<JwtHeader> HeaderDefault =
-            new Lazy<JwtHeader>(
-                () =>
-                    EventToken.ComposeDefaultHeader());
-
-        private static readonly Lazy<SecurityTokenHandler> TokenSerializer =
-            new Lazy<SecurityTokenHandler>(
-                    () =>
-                        new JwtSecurityTokenHandler());
-
-        private EventToken(string issuer, JwtHeader header)
-        {
-            if (string.IsNullOrWhiteSpace(issuer))
-            {
-                throw new ArgumentNullException(nameof(issuer));
-            }
-
-            this.Issuer = issuer;
-            this.Header = header ?? throw new ArgumentNullException(nameof(header));
-
-            this.Identifier = Guid.NewGuid().ToString();
-            this.IssuedAt = DateTime.UtcNow;
-        }
-
-        public EventToken(string issuer, JwtHeader header, IDictionary<string, object> events)
-            : this(issuer, header)
-        {
-            this.Events = events ?? throw new ArgumentNullException(nameof(events));
-        }
-
-        public EventToken(string issuer, Dictionary<string, object> events)
-            : this(issuer, EventToken.HeaderDefault.Value, events)
-        {
-        }
-
-        public EventToken(string serialized)
-        {
-            if (string.IsNullOrWhiteSpace(serialized))
-            {
-                throw new ArgumentNullException(nameof(serialized));
-            }
-
-            JwtSecurityToken token = new JwtSecurityToken(serialized);
-            this.Header = token.Header;
-
-            this.ParseIdentifier(token.Payload);
-            this.ParseIssuer(token.Payload);
-            this.ParseAudience(token.Payload);
-            this.ParseIssuedAt(token.Payload);
-            this.ParseNotBefore(token.Payload);
-            this.ParseSubject(token.Payload);
-            this.ParseExpiration(token.Payload);
-            this.ParseEvents(token.Payload);
-            this.ParseTransaction(token.Payload);
-        }
-
-        public IReadOnlyCollection<string> Audience
-        {
-            get;
-            set;
-        }
-
-        public IDictionary<string, object> Events
-        {
-            get;
-            private set;
-        }
-
-        public DateTime? Expiration
-        {
-            get;
-            set;
-        }
-
-        public JwtHeader Header
-        {
-            get;
-            private set;
-        }
-
-        public string Identifier
-        {
-            get;
-            private set;
-        }
-
-        public DateTime IssuedAt
-        {
-            get;
-            private set;
-        }
-
-        public string Issuer
-        {
-            get;
-            private set;
-        }
-
-        public DateTime? NotBefore
-        {
-            get;
-            private set;
-        }
-
-        public string Subject
-        {
-            get;
-            set;
-        }
-
-        public string Transaction
-        {
-            get;
-            set;
-        }
-
-        private static JwtHeader ComposeDefaultHeader()
-        {
-            JwtHeader result = new JwtHeader();
-            result.Add(EventToken.HeaderKeyAlgorithm, EventToken.JwtAlgorithmNone);
-            return result;
-        }
-
-        private void ParseAudience(JwtPayload payload)
-        {
-            if (null == payload)
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            if (!payload.TryGetValue(EventTokenClaimTypes.Audience, out object value) || null == value)
-            {
-                return;
-            }
-
-            object[] values = value as object[];
-            if (null == values)
-            {
-                string exceptionMessage =
-                string.Format(
-                    CultureInfo.InvariantCulture,
-                    SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenInvalidClaimValueTemplate,
-                    EventTokenClaimTypes.Audience,
-                    value);
-                throw new ArgumentException(exceptionMessage);
-            }
-
-            IReadOnlyCollection<string> audience =
-                values
-                .OfType<string>()
-                .ToArray();
-            if (audience.Count != values.Length)
-            {
-                string exceptionMessage =
-                string.Format(
-                    CultureInfo.InvariantCulture,
-                    SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenInvalidClaimValueTemplate,
-                    EventTokenClaimTypes.Audience,
-                    value);
-                throw new ArgumentException(exceptionMessage);
-            }
-
-            this.Audience = audience;
-        }
-
-        private void ParseEvents(JwtPayload payload)
-        {
-            if (null == payload)
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            if (!payload.TryGetValue(EventTokenClaimTypes.Events, out object value) || null == value)
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenMissingClaimTemplate,
-                        EventTokenClaimTypes.Events);
-                throw new ArgumentException(exceptionMessage);
-            }
-
-            IDictionary<string, object> events = value as Dictionary<string, object>;
-            if (null == events)
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenInvalidClaimValueTemplate,
-                        EventTokenClaimTypes.Events,
-                        value);
-                throw new ArgumentException(exceptionMessage);
-            }
-            this.Events = events;
-        }
-
-        private void ParseExpiration(JwtPayload payload)
-        {
-            if (null == payload)
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            if (!payload.TryGetValue(EventTokenClaimTypes.Expiration, out object value) || null == value)
-            {
-                return;
-            }
-
-            string serializedValue = value.ToString();
-            if (!long.TryParse(serializedValue, out long expiration))
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenInvalidClaimValueTemplate,
-                        EventTokenClaimTypes.Expiration,
-                        value);
-                throw new ArgumentException(exceptionMessage);
-            }
-
-            this.Expiration = new UnixTime(expiration).ToUniversalTime();
-            if (this.Expiration > DateTime.UtcNow)
-            {
-                throw new SecurityTokenExpiredException(SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenExpired);
-            }
-        }
-
-        private void ParseIdentifier(JwtPayload payload)
-        {
-            if (null == payload)
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            if (!payload.TryGetValue(EventTokenClaimTypes.Identifier, out object value) || null == value)
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenMissingClaimTemplate,
-                        EventTokenClaimTypes.Identifier);
-                throw new ArgumentException(exceptionMessage);
-            }
-
-            string identifier = value as string;
-            if (string.IsNullOrWhiteSpace(identifier))
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenInvalidClaimValueTemplate,
-                        EventTokenClaimTypes.Identifier,
-                        value);
-                throw new ArgumentException(exceptionMessage);
-            }
-            this.Identifier = identifier;
-        }
-
-        private void ParseIssuedAt(JwtPayload payload)
-        {
-            if (null == payload)
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            if (!payload.TryGetValue(EventTokenClaimTypes.IssuedAt, out object value) || null == value)
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenMissingClaimTemplate,
-                        EventTokenClaimTypes.IssuedAt);
-                throw new ArgumentException(exceptionMessage);
-            }
-
-            string serializedValue = value.ToString();
-            if (!long.TryParse(serializedValue, out long issuedAt))
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenMissingClaimTemplate,
-                        EventTokenClaimTypes.IssuedAt);
-                throw new ArgumentException(exceptionMessage);
-            }
-            this.IssuedAt = new UnixTime(issuedAt).ToUniversalTime();
-        }
-
-        private void ParseIssuer(JwtPayload payload)
-        {
-            if (null == payload)
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            if (!payload.TryGetValue(EventTokenClaimTypes.Issuer, out object value) || null == value)
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenMissingClaimTemplate,
-                        EventTokenClaimTypes.Issuer);
-                throw new ArgumentException(exceptionMessage);
-            }
-
-            string issuer = value as string;
-            if (string.IsNullOrWhiteSpace(issuer))
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenInvalidClaimValueTemplate,
-                        EventTokenClaimTypes.Issuer,
-                        value);
-                throw new ArgumentException(exceptionMessage);
-            }
-            this.Issuer = issuer;
-        }
-
-        private void ParseNotBefore(JwtPayload payload)
-        {
-            if (null == payload)
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            if (!payload.TryGetValue(EventTokenClaimTypes.NotBefore, out object value) || null == value)
-            {
-                return;
-            }
-
-            string serializedValue = value.ToString();
-            if (!long.TryParse(serializedValue, out long notBefore))
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenInvalidClaimValueTemplate,
-                        EventTokenClaimTypes.NotBefore,
-                        value);
-                throw new ArgumentException(exceptionMessage);
-            }
-
-            this.NotBefore = new UnixTime(notBefore).ToUniversalTime();
-        }
-
-        private void ParseSubject(JwtPayload payload)
-        {
-            if (null == payload)
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            if (!payload.TryGetValue(EventTokenClaimTypes.Subject, out object value) || null == value)
-            {
-                return;
-            }
-
-            string subject = value as string;
-            if (null == subject)
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenInvalidClaimValueTemplate,
-                        EventTokenClaimTypes.Subject,
-                        value);
-                throw new ArgumentException(exceptionMessage);
-            }
-
-            this.Subject = subject;
-        }
-
-        private void ParseTransaction(JwtPayload payload)
-        {
-            if (null == payload)
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            if (!payload.TryGetValue(EventTokenClaimTypes.Transaction, out object value) || null == value)
-            {
-                return;
-            }
-
-            string transaction = value as string;
-            if (null == transaction)
-            {
-                string exceptionMessage =
-                string.Format(
-                    CultureInfo.InvariantCulture,
-                    SystemForCrossDomainIdentityManagementSchemasResources.ExceptionEventTokenInvalidClaimValueTemplate,
-                    EventTokenClaimTypes.Transaction,
-                    value);
-                throw new ArgumentException(exceptionMessage);
-            }
-
-            this.Transaction = transaction;
-        }
-
-        public override string ToString()
-        {
-            JwtPayload payload = new JwtPayload();
-
-            payload.Add(EventTokenClaimTypes.Identifier, this.Identifier);
-
-            payload.Add(EventTokenClaimTypes.Issuer, this.Issuer);
-
-            if (this.Audience != null && this.Audience.Any())
-            {
-                string[] audience = this.Audience.ToArray();
-                payload.Add(EventTokenClaimTypes.Audience, audience);
-            }
-
-            long issuedAt = new UnixTime(this.IssuedAt).EpochTimestamp;
-            payload.Add(EventTokenClaimTypes.IssuedAt, issuedAt);
-
-            if (this.NotBefore.HasValue)
-            {
-                long notBefore = new UnixTime(this.NotBefore.Value).EpochTimestamp;
-                payload.Add(EventTokenClaimTypes.NotBefore, notBefore);
-            }
-
-            if (!string.IsNullOrWhiteSpace(this.Subject))
-            {
-                payload.Add(EventTokenClaimTypes.Subject, this.Subject);
-            }
-
-            if (this.Expiration.HasValue)
-            {
-                long expiration = new UnixTime(this.Expiration.Value).EpochTimestamp;
-                payload.Add(EventTokenClaimTypes.Expiration, expiration);
-            }
-
-            payload.Add(EventTokenClaimTypes.Events, this.Events);
-
-            if (!string.IsNullOrWhiteSpace(this.Transaction))
-            {
-                payload.Add(EventTokenClaimTypes.Transaction, this.Transaction);
-            }
-
-            SecurityToken token = new JwtSecurityToken(this.Header, payload);
-            string result = EventToken.TokenSerializer.Value.WriteToken(token);
-            return result;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventTokenClaimTypes.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventTokenClaimTypes.cs
deleted file mode 100644
index 9ba4b5ae..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventTokenClaimTypes.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public static class EventTokenClaimTypes
-    {
-        public const string Audience = "aud";
-        public const string Expiration = "exp";
-        public const string Events = "events";
-        public const string Identifier = "jti";
-        public const string IssuedAt = "iat";
-        public const string Issuer = "iss";
-        public const string NotBefore = "nbf";
-        public const string Subject = "sub";
-        public const string Transaction = "txn";
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventTokenDecorator.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventTokenDecorator.cs
deleted file mode 100644
index b7b97389..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventTokenDecorator.cs
+++ /dev/null
@@ -1,139 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.IdentityModel.Tokens.Jwt;
-
-    public abstract class EventTokenDecorator : IEventToken
-    {
-        protected EventTokenDecorator(IEventToken innerToken)
-        {
-            this.InnerToken = innerToken ?? throw new ArgumentNullException(nameof(innerToken));
-        }
-
-        protected EventTokenDecorator(string serialized)
-            : this(new EventToken(serialized))
-        {
-        }
-
-        public IReadOnlyCollection<string> Audience
-        {
-            get
-            {
-                IReadOnlyCollection<string> result = this.InnerToken.Audience;
-                return result;
-            }
-
-            set
-            {
-                this.InnerToken.Audience = value;
-            }
-        }
-
-        public IDictionary<string, object> Events
-        {
-            get
-            {
-                IDictionary<string, object> results = this.InnerToken.Events;
-                return results;
-            }
-        }
-
-        public DateTime? Expiration
-        {
-            get
-            {
-                DateTime? result = this.InnerToken.Expiration;
-                return result;
-            }
-
-            set
-            {
-                this.InnerToken.Expiration = value;
-            }
-        }
-
-        public JwtHeader Header
-        {
-            get
-            {
-                JwtHeader result = this.InnerToken.Header;
-                return result;
-            }
-        }
-
-        public string Identifier
-        {
-            get
-            {
-                string result = this.InnerToken.Identifier;
-                return result;
-            }
-        }
-
-        public IEventToken InnerToken
-        {
-            get;
-            private set;
-        }
-
-        public DateTime IssuedAt
-        {
-            get
-            {
-                DateTime result = this.InnerToken.IssuedAt;
-                return result;
-            }
-        }
-
-        public string Issuer
-        {
-            get
-            {
-                string result = this.InnerToken.Issuer;
-                return result;
-            }
-        }
-
-        public DateTime? NotBefore
-        {
-            get
-            {
-                DateTime? result = this.InnerToken.NotBefore;
-                return result;
-            }
-        }
-
-        public string Subject
-        {
-            get
-            {
-                string result = this.InnerToken.Subject;
-                return result;
-            }
-
-            set
-            {
-                throw new NotImplementedException();
-            }
-        }
-
-        public string Transaction
-        {
-            get
-            {
-                string result = this.InnerToken.Transaction;
-                return result;
-            }
-
-            set
-            {
-                this.InnerToken.Transaction = value;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventTokenFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventTokenFactory.cs
deleted file mode 100644
index 85394520..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/EventTokenFactory.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.IdentityModel.Tokens.Jwt;
-
-    public abstract class EventTokenFactory
-    {
-        protected EventTokenFactory(string issuer, JwtHeader header)
-        {
-            if (string.IsNullOrWhiteSpace(issuer))
-            {
-                throw new ArgumentNullException(nameof(issuer));
-            }
-
-            this.Issuer = issuer;
-            this.Header = header ?? throw new ArgumentNullException(nameof(header));
-        }
-
-        public JwtHeader Header
-        {
-            get;
-            private set;
-        }
-
-        public string Issuer
-        {
-            get;
-            private set;
-        }
-
-        public abstract IEventToken Create(IDictionary<string, object> events);
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/IChange.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/IChange.cs
deleted file mode 100644
index f9273a77..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/IChange.cs
+++ /dev/null
@@ -1,11 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public interface IChange
-    {
-        string Watermark { get; set; }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/IJsonNormalizationBehavior.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/IJsonNormalizationBehavior.cs
deleted file mode 100644
index 3380442c..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/IJsonNormalizationBehavior.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-
-    public interface IJsonNormalizationBehavior
-    {
-        IReadOnlyDictionary<string, object> Normalize(IReadOnlyDictionary<string, object> json);
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/IUnixTime.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/IUnixTime.cs
deleted file mode 100644
index d588ee84..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/IUnixTime.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-
-    public interface IUnixTime
-    {
-        long EpochTimestamp { get; }
-
-        DateTime ToUniversalTime();
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/JsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/JsonDeserializingFactory.cs
deleted file mode 100644
index 39972496..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/JsonDeserializingFactory.cs
+++ /dev/null
@@ -1,167 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.IO;
-    using System.Runtime.Serialization;
-    using System.Runtime.Serialization.Json;
-    using System.Threading;
-
-    public abstract class JsonDeserializingFactory<TDataContract> : IJsonNormalizationBehavior
-    {
-        private static readonly Lazy<DataContractJsonSerializerSettings> JsonSerializerSettings =
-            new Lazy<DataContractJsonSerializerSettings>(
-                () =>
-                    new DataContractJsonSerializerSettings()
-                    {
-                        EmitTypeInformation = EmitTypeInformation.Never
-                    });
-
-        private static readonly Lazy<DataContractJsonSerializer> JsonSerializer =
-            new Lazy<DataContractJsonSerializer>(
-                () =>
-                    new DataContractJsonSerializer(
-                        typeof(TDataContract),
-                        JsonDeserializingFactory<TDataContract>.JsonSerializerSettings.Value));
-
-        private IJsonNormalizationBehavior jsonNormalizer;
-
-        public bool AcceptLargeObjects
-        {
-            get;
-            set;
-        }
-
-        public virtual IJsonNormalizationBehavior JsonNormalizer
-        {
-            get
-            {
-                IJsonNormalizationBehavior result =
-                    LazyInitializer.EnsureInitialized<IJsonNormalizationBehavior>(
-                        ref this.jsonNormalizer,
-                        () =>
-                            new JsonNormalizer());
-                return result;
-            }
-        }
-
-        public virtual TDataContract Create(IReadOnlyDictionary<string, object> json)
-        {
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            IReadOnlyDictionary<string, object> normalizedJson = this.Normalize(json);
-            string serialized = JsonFactory.Instance.Create(normalizedJson, this.AcceptLargeObjects);
-
-            MemoryStream stream = null;
-            try
-            {
-                stream = new MemoryStream();
-                Stream streamed = stream;
-                StreamWriter writer = null;
-                try
-                {
-                    writer = new StreamWriter(stream);
-                    stream = null;
-                    writer.Write(serialized);
-                    writer.Flush();
-
-                    streamed.Position = 0;
-                    TDataContract result =
-                        (TDataContract)JsonDeserializingFactory<TDataContract>.JsonSerializer.Value.ReadObject(
-                            streamed);
-                    return result;
-                }
-                finally
-                {
-                    if (writer != null)
-                    {
-                        writer.Close();
-                        writer = null;
-                    }
-                }
-            }
-            finally
-            {
-                if (stream != null)
-                {
-                    stream.Close();
-#pragma warning disable IDE0059 // Value assigned to symbol is never used
-                    stream = null;
-#pragma warning restore IDE0059 // Value assigned to symbol is never used
-                }
-            }
-        }
-
-        public virtual TDataContract Create(string json)
-        {
-            if (string.IsNullOrWhiteSpace(json))
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            IReadOnlyDictionary<string, object> keyedValues = JsonFactory.Instance.Create(json, this.AcceptLargeObjects);
-            TDataContract result = this.Create(keyedValues);
-            return result;
-        }
-
-        public IReadOnlyDictionary<string, object> Normalize(IReadOnlyDictionary<string, object> json)
-        {
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            IReadOnlyDictionary<string, object> result = this.JsonNormalizer.Normalize(json);
-            return result;
-        }
-
-        public virtual TDataContract Read(string json)
-        {
-            MemoryStream stream = null;
-            try
-            {
-                stream = new MemoryStream();
-                Stream streamed = stream;
-                StreamWriter writer = null;
-                try
-                {
-                    writer = new StreamWriter(stream);
-                    stream = null;
-                    writer.Write(json);
-                    writer.Flush();
-
-                    streamed.Position = 0;
-                    TDataContract result =
-                        (TDataContract)JsonDeserializingFactory<TDataContract>.JsonSerializer.Value.ReadObject(
-                            streamed);
-                    return result;
-                }
-                finally
-                {
-                    if (writer != null)
-                    {
-                        writer.Close();
-                        writer = null;
-                    }
-                }
-            }
-            finally
-            {
-                if (stream != null)
-                {
-                    stream.Close();
-#pragma warning disable IDE0059 // Value assigned to symbol is never used
-                    stream = null;
-#pragma warning restore IDE0059 // Value assigned to symbol is never used
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/JsonNormalizer.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/JsonNormalizer.cs
deleted file mode 100644
index 7f3524b9..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/JsonNormalizer.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Linq;
-    using System.Reflection;
-    using System.Threading;
-
-    public sealed class JsonNormalizer : JsonNormalizerTemplate
-    {
-        private IReadOnlyCollection<string> attributeNames;
-
-        public override IReadOnlyCollection<string> AttributeNames
-        {
-            get
-            {
-                IReadOnlyCollection<string> result =
-                    LazyInitializer.EnsureInitialized<IReadOnlyCollection<string>>(
-                        ref this.attributeNames,
-                        JsonNormalizer.CollectAttributeNames);
-                return result;
-            }
-        }
-
-        private static IReadOnlyCollection<string> CollectAttributeNames()
-        {
-            Type attributeNamesType = typeof(AttributeNames);
-            IReadOnlyCollection<FieldInfo> members = attributeNamesType.GetFields(BindingFlags.Public | BindingFlags.Static);
-            IReadOnlyCollection<string> result =
-                members
-                .Select(
-                    (FieldInfo item) =>
-                        item.GetValue(null))
-                .Cast<string>()
-                .ToArray();
-            return result;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/JsonNormalizerTemplate.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/JsonNormalizerTemplate.cs
deleted file mode 100644
index 3bae89fc..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/JsonNormalizerTemplate.cs
+++ /dev/null
@@ -1,116 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections;
-    using System.Collections.Generic;
-    using System.Collections.ObjectModel;
-    using System.Linq;
-
-    public abstract class JsonNormalizerTemplate : IJsonNormalizationBehavior
-    {
-        public abstract IReadOnlyCollection<string> AttributeNames
-        {
-            get;
-        }
-
-        private IEnumerable<KeyValuePair<string, object>> Normalize(IReadOnlyCollection<KeyValuePair<string, object>> json)
-        {
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            int countElements = json.CheckedCount();
-            IDictionary<string, object> result = new Dictionary<string, object>(countElements);
-            foreach (KeyValuePair<string, object> element in json)
-            {
-                string key;
-                key = element.Key;
-                object value = element.Value;
-                string attributeName =
-                    this
-                    .AttributeNames
-                    .SingleOrDefault(
-                        (string item) =>
-                            string.Equals(item, key, StringComparison.OrdinalIgnoreCase));
-                if (attributeName != null)
-                {
-                    if (!string.Equals(key, attributeName, StringComparison.Ordinal))
-                    {
-                        key = attributeName;
-                    }
-
-                    switch (value)
-                    {
-                        case IEnumerable<KeyValuePair<string, object>> jsonValue:
-                            value = this.Normalize(jsonValue);
-                            break;
-                        case ArrayList jsonCollectionValue:
-                            ArrayList jsonCollectionNormalized = new ArrayList();
-                            foreach (object innerValue in jsonCollectionValue)
-                            {
-                                IEnumerable<KeyValuePair<string, object>> innerObject =
-                                    innerValue as IEnumerable<KeyValuePair<string, object>>;
-                                if (innerObject != null)
-                                {
-                                    IEnumerable<KeyValuePair<string, object>> normalizedInnerObject = this.Normalize(innerObject);
-                                    jsonCollectionNormalized.Add(normalizedInnerObject);
-                                }
-                                else
-                                {
-                                    jsonCollectionNormalized.Add(innerValue);
-                                }
-                            }
-
-                            value = jsonCollectionNormalized;
-                            break;
-                        default:
-                            break;
-                    }
-                }
-
-                result.Add(key, value);
-            }
-
-            return result;
-        }
-
-        private IEnumerable<KeyValuePair<string, object>> Normalize(IEnumerable<KeyValuePair<string, object>> json)
-        {
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            IReadOnlyCollection<KeyValuePair<string, object>> materializedJson = json.ToArray();
-            IEnumerable<KeyValuePair<string, object>> result = this.Normalize(materializedJson);
-            return result;
-        }
-
-        public IReadOnlyDictionary<string, object> Normalize(IReadOnlyDictionary<string, object> json)
-        {
-            if (null == json)
-            {
-                throw new ArgumentNullException(nameof(json));
-            }
-
-            IReadOnlyCollection<KeyValuePair<string, object>> keyedPairs =
-               (IReadOnlyCollection<KeyValuePair<string, object>>)json;
-            Dictionary<string, object> normalizedJson =
-                this
-                .Normalize(keyedPairs)
-                .ToDictionary(
-                    (KeyValuePair<string, object> item) =>
-                        item.Key,
-                    (KeyValuePair<string, object> item) =>
-                        item.Value);
-            IReadOnlyDictionary<string, object> result =
-                new ReadOnlyDictionary<string, object>(normalizedJson);
-            return result;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/LogicalOperator.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/LogicalOperator.cs
deleted file mode 100644
index 5b0303e4..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/LogicalOperator.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public enum LogicalOperator
-    {
-        And,
-        Or
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/ManagerDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/ManagerDeserializingFactory.cs
deleted file mode 100644
index e3b87c96..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/ManagerDeserializingFactory.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public class ManagerDeserializingFactory : JsonDeserializingFactory<Manager>
-    {
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Member.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Member.cs
index f6c444a5..ab9db39b 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Member.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Member.cs
@@ -7,7 +7,24 @@ namespace Microsoft.SCIM
     using System.Runtime.Serialization;
 
     [DataContract]
-    public sealed class Member : MemberBase
+    public sealed class Member
     {
+        internal Member()
+        {
+        }
+
+        [DataMember(Name = AttributeNames.Type, IsRequired = false, EmitDefaultValue = false)]
+        public string TypeName
+        {
+            get;
+            set;
+        }
+
+        [DataMember(Name = AttributeNames.Value)]
+        public string Value
+        {
+            get;
+            set;
+        }
     }
-}
\ No newline at end of file
+}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/MemberBase.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/MemberBase.cs
deleted file mode 100644
index dbf43c2a..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/MemberBase.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System.Runtime.Serialization;
-
-    [DataContract]
-    public abstract class MemberBase
-    {
-        internal MemberBase()
-        {
-        }
-
-        [DataMember(Name = AttributeNames.Type, IsRequired = false, EmitDefaultValue = false)]
-        public string TypeName
-        {
-            get;
-            set;
-        }
-
-        [DataMember(Name = AttributeNames.Value)]
-        public string Value
-        {
-            get;
-            set;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Photo.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Photo.cs
deleted file mode 100644
index 738f9b8a..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Photo.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System.Runtime.Serialization;
-
-    [DataContract]
-    public sealed class Photo : PhotoBase
-    {
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/PhotoBase.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/PhotoBase.cs
deleted file mode 100644
index fc0ce40c..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/PhotoBase.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System.Runtime.Serialization;
-
-    [DataContract]
-    public class PhotoBase : TypedValue
-    {
-        internal PhotoBase()
-        {
-        }
-
-        public const string Photo = "photo";
-        public const string Thumbnail = "thumbnail";
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/PluralUnsecuredEventTokenFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/PluralUnsecuredEventTokenFactory.cs
deleted file mode 100644
index daa442c5..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/PluralUnsecuredEventTokenFactory.cs
+++ /dev/null
@@ -1,28 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-
-    public class PluralUnsecuredEventTokenFactory : UnsecuredEventTokenFactory
-    {
-        public PluralUnsecuredEventTokenFactory(string issuer)
-            : base(issuer)
-        {
-        }
-
-        public override IEventToken Create(IDictionary<string, object> events)
-        {
-            if (null == events)
-            {
-                throw new ArgumentNullException(nameof(events));
-            }
-
-            IEventToken result = new EventToken(this.Issuer, this.Header, events);
-            return result;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/QualifiedResource.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/QualifiedResource.cs
deleted file mode 100644
index 6294a5ff..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/QualifiedResource.cs
+++ /dev/null
@@ -1,112 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Globalization;
-    using System.Linq;
-    using System.Runtime.Serialization;
-
-    [DataContract]
-    public abstract class QualifiedResource : Resource
-    {
-        private const string ResourceSchemaIdentifierTemplateSuffix = "{0}";
-
-        private string resourceSchemaIdentifierTemplate;
-
-        protected QualifiedResource(string schemaIdentifier, string resourceSchemaPrefix)
-        {
-            this.OnInitialized(schemaIdentifier, resourceSchemaPrefix);
-        }
-
-        private string ResourceSchemaPrefix
-        {
-            get;
-            set;
-        }
-
-        public virtual void AddResourceSchemaIdentifier(string resourceTypeName)
-        {
-            if (this.TryGetResourceTypeName(out string value))
-            {
-                string typeName = this.GetType().Name;
-                string errorMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionMultipleQualifiedResourceTypeIdentifiersTemplate,
-                        typeName);
-                throw new InvalidOperationException(errorMessage);
-            }
-            string schemaIdentifier =
-                string.Format(
-                    CultureInfo.InvariantCulture,
-                    this.resourceSchemaIdentifierTemplate,
-                    resourceTypeName);
-            this.AddSchema(schemaIdentifier);
-        }
-
-        public void OnDeserialized(string schemaIdentifier, string resourceSchemaPrefix)
-        {
-            this.OnInitialized(schemaIdentifier, resourceSchemaPrefix);
-            int countResourceSchemaIdentifiers =
-                this
-                .Schemas
-                .Where(
-                    (string item) =>
-                        item.StartsWith(this.ResourceSchemaPrefix, StringComparison.Ordinal))
-                .Count();
-            if (countResourceSchemaIdentifiers > 1)
-            {
-                string typeName = this.GetType().Name;
-                string errorMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementSchemasResources.ExceptionMultipleQualifiedResourceTypeIdentifiersTemplate,
-                        typeName);
-                throw new InvalidOperationException(errorMessage);
-            }
-        }
-
-        private void OnInitialized(string schemaIdentifier, string resourceSchemaPrefix)
-        {
-            if (string.IsNullOrWhiteSpace(schemaIdentifier))
-            {
-                throw new ArgumentNullException(nameof(schemaIdentifier));
-            }
-
-            if (string.IsNullOrWhiteSpace(resourceSchemaPrefix))
-            {
-                throw new ArgumentNullException(nameof(resourceSchemaPrefix));
-            }
-
-            this.ResourceSchemaPrefix = resourceSchemaPrefix;
-            this.resourceSchemaIdentifierTemplate =
-                this.ResourceSchemaPrefix + QualifiedResource.ResourceSchemaIdentifierTemplateSuffix;
-        }
-
-        public virtual bool TryGetResourceTypeName(out string resourceTypeName)
-        {
-            resourceTypeName = null;
-
-            string resourceSchemaIdentifier =
-                this
-                .Schemas
-                .SingleOrDefault(
-                    (string item) =>
-                        item.StartsWith(this.ResourceSchemaPrefix, StringComparison.Ordinal));
-            if (string.IsNullOrWhiteSpace(resourceSchemaIdentifier))
-            {
-                return false;
-            }
-            string buffer = resourceSchemaIdentifier.Substring(this.ResourceSchemaPrefix.Length);
-            if (buffer.Length <= 0)
-            {
-                return false;
-            }
-            resourceTypeName = buffer;
-            return true;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Role.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Role.cs
index caafb6ad..399f11b8 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Role.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/Role.cs
@@ -7,8 +7,20 @@ namespace Microsoft.SCIM
     using System.Runtime.Serialization;
 
     [DataContract]
-    public sealed class Role : RoleBase
+    public sealed class Role : TypedItem
     {
+        [DataMember(Name = AttributeNames.Display, IsRequired = false, EmitDefaultValue = false)]
+        public string Display
+        {
+            get;
+            set;
+        }
 
+        [DataMember(Name = AttributeNames.Value, IsRequired = false, EmitDefaultValue = false)]
+        public string Value
+        {
+            get;
+            set;
+        }
     }
 }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/RoleBase.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/RoleBase.cs
deleted file mode 100644
index 3bb609f0..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/RoleBase.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System.Runtime.Serialization;
-
-    [DataContract]
-    public abstract class RoleBase : TypedItem
-    {
-        [DataMember(Name = AttributeNames.Display, IsRequired = false, EmitDefaultValue = false)]
-        public string Display
-        {
-            get;
-            set;
-        }
-
-        [DataMember(Name = AttributeNames.Value, IsRequired = false, EmitDefaultValue = false)]
-        public string Value
-        {
-            get;
-            set;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/SingularEventToken.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/SingularEventToken.cs
deleted file mode 100644
index 2ef43dd6..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/SingularEventToken.cs
+++ /dev/null
@@ -1,44 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Collections.ObjectModel;
-    using System.Linq;
-
-    public abstract class SingularEventToken : EventTokenDecorator
-    {
-        protected SingularEventToken(IEventToken innerToken)
-            : base(innerToken)
-        {
-            if (this.InnerToken.Events.Count != 1)
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementSchemasResources.ExceptionSingleEventExpected);
-            }
-
-            KeyValuePair<string, object> singleEvent = this.InnerToken.Events.Single();
-            this.SchemaIdentifier = singleEvent.Key;
-            this.Event = new ReadOnlyDictionary<string, object>((IDictionary<string, object>)singleEvent.Value);
-        }
-
-        protected SingularEventToken(string serialized)
-            : this(new EventToken(serialized))
-        {
-        }
-
-        public IReadOnlyDictionary<string, object> Event
-        {
-            get;
-            private set;
-        }
-
-        public string SchemaIdentifier
-        {
-            get;
-            private set;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/SingularUnsecuredEventTokenFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/SingularUnsecuredEventTokenFactory.cs
deleted file mode 100644
index a0c24646..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/SingularUnsecuredEventTokenFactory.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-
-    public class SingularUnsecuredEventTokenFactory : UnsecuredEventTokenFactory
-    {
-        public SingularUnsecuredEventTokenFactory(string issuer, string eventSchemaIdentifier)
-            : base(issuer)
-        {
-            if (string.IsNullOrWhiteSpace(eventSchemaIdentifier))
-            {
-                throw new ArgumentNullException(nameof(eventSchemaIdentifier));
-            }
-
-            this.EventSchemaIdentifier = eventSchemaIdentifier;
-        }
-
-        private string EventSchemaIdentifier
-        {
-            get;
-            set;
-        }
-
-        public override IEventToken Create(IDictionary<string, object> events)
-        {
-            IDictionary<string, object> tokenEvents = new Dictionary<string, object>(1);
-            tokenEvents.Add(this.EventSchemaIdentifier, events);
-            IEventToken result = new EventToken(this.Issuer, this.Header, tokenEvents);
-            return result;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/SpecificationVersion.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/SpecificationVersion.cs
deleted file mode 100644
index 13c0eac3..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/SpecificationVersion.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-
-    public static class SpecificationVersion
-    {
-        private static readonly Lazy<Version> VersionOneOhValue =
-            new Lazy<System.Version>(
-                () =>
-                    new Version(1, 0));
-
-        private static readonly Lazy<Version> VersionOneOneValue =
-            new Lazy<Version>(
-                () =>
-                    new Version(1, 1));
-
-        private static readonly Lazy<Version> VersionTwoOhValue =
-            new Lazy<Version>(
-                () =>
-                    new Version(2, 0));
-
-        // NOTE: This version is to be used for DCaaS only.
-        private static readonly Lazy<Version> VersionTwoOhOneValue =
-            new Lazy<Version>(
-                () =>
-                    new Version(2, 0, 1));
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Oh", Justification = "Not an abbreviation")]
-        public static Version VersionOneOh
-        {
-            get
-            {
-                return SpecificationVersion.VersionOneOhValue.Value;
-            }
-        }
-
-        public static Version VersionOneOne
-        {
-            get
-            {
-                return SpecificationVersion.VersionOneOneValue.Value;
-            }
-        }
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Oh", Justification = "Not an abbreviation")]
-        public static Version VersionTwoOhOne
-        {
-            get
-            {
-                return SpecificationVersion.VersionTwoOhOneValue.Value;
-            }
-        }
-
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Oh", Justification = "Not an abbreviation")]
-        public static Version VersionTwoOh
-        {
-            get
-            {
-                return SpecificationVersion.VersionTwoOhValue.Value;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/TypeSchemeJsonDeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/TypeSchemeJsonDeserializingFactory.cs
deleted file mode 100644
index 9d127093..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/TypeSchemeJsonDeserializingFactory.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    public sealed class TypeSchemeJsonDeserializingFactory : JsonDeserializingFactory<TypeScheme>
-    {
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/UnixTime.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/UnixTime.cs
deleted file mode 100644
index 54c4d5ff..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/UnixTime.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Globalization;
-
-    // Refer to https://en.wikipedia.org/wiki/Unix_time
-    public class UnixTime : IUnixTime
-    {
-        public static readonly DateTime Epoch =
-            new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-
-        public UnixTime(long epochTimestamp)
-        {
-            this.EpochTimestamp = epochTimestamp;
-        }
-
-        public UnixTime(int epochTimestamp)
-            : this(Convert.ToInt64(epochTimestamp))
-        {
-        }
-
-        public UnixTime(double epochTimestamp)
-            : this(Convert.ToInt64(epochTimestamp))
-        {
-        }
-
-        public UnixTime(TimeSpan sinceEpoch)
-            : this(sinceEpoch.TotalSeconds)
-        {
-        }
-
-        public UnixTime(DateTime dateTime)
-            : this(dateTime.ToUniversalTime().Subtract(UnixTime.Epoch))
-        {
-        }
-
-        public DateTime ToUniversalTime()
-        {
-            DateTime result = UnixTime.Epoch.AddSeconds(this.EpochTimestamp);
-            return result;
-        }
-
-        public long EpochTimestamp
-        {
-            get;
-            private set;
-        }
-
-        public override string ToString()
-        {
-            string result = this.EpochTimestamp.ToString(CultureInfo.InvariantCulture);
-            return result;
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/UnsecuredEventTokenFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/UnsecuredEventTokenFactory.cs
deleted file mode 100644
index 6e09efa7..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/UnsecuredEventTokenFactory.cs
+++ /dev/null
@@ -1,30 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.IdentityModel.Tokens.Jwt;
-
-    public abstract class UnsecuredEventTokenFactory : EventTokenFactory
-    {
-
-        private static readonly Lazy<JwtHeader> UnsecuredTokenHeader =
-            new Lazy<JwtHeader>(
-                () =>
-                    UnsecuredEventTokenFactory.ComposeHeader());
-
-        protected UnsecuredEventTokenFactory(string issuer)
-            : base(issuer, UnsecuredEventTokenFactory.UnsecuredTokenHeader.Value)
-        {
-        }
-
-        private static JwtHeader ComposeHeader()
-        {
-            JwtHeader result = new JwtHeader();
-            result.Add(EventToken.HeaderKeyAlgorithm, EventToken.JwtAlgorithmNone);
-            return result;
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/User.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/User.cs
deleted file mode 100644
index 693c1d99..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Schemas/User.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System.Runtime.Serialization;
-
-    [DataContract]
-    public sealed class User : UserBase
-    {
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkCreationOperationState.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkCreationOperationState.cs
index ca597e18..466b0016 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkCreationOperationState.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkCreationOperationState.cs
@@ -128,7 +128,7 @@ public BulkCreationOperationState(
                 }
                 if (null == resource)
                 {
-                    string invalidOperationExceptionMessage = 
+                    string invalidOperationExceptionMessage =
                         string.Format(
                             CultureInfo.InvariantCulture,
                             SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidOperationTemplate,
@@ -136,7 +136,7 @@ public BulkCreationOperationState(
                     throw new ArgumentException(invalidOperationExceptionMessage);
                 }
                 this.creationRequest =
-                        new CreationRequest(request.Request, resource, request.CorrelationIdentifier,
+                        new SystemForCrossDomainIdentityManagementRequest<Resource>(request.HttpContext, resource, request.CorrelationIdentifier,
                         request.Extensions);
             }
             else
@@ -151,9 +151,9 @@ public BulkCreationOperationState(
         }
 
         public IReadOnlyCollection<IBulkUpdateOperationContext> Dependents => this.dependentsWrapper;
-       
+
         public IReadOnlyCollection<IBulkUpdateOperationContext> Subordinates => this.subordinatesWrapper;
-       
+
         public void AddDependent(IBulkUpdateOperationContext dependent)
         {
             if (null == dependent)
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkDeletionOperationState.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkDeletionOperationState.cs
index 2da7682b..3760879f 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkDeletionOperationState.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkDeletionOperationState.cs
@@ -49,8 +49,8 @@ public override bool TryPrepareRequest(out IRequest<IResourceIdentifier> request
             }
 
             request =
-                new DeletionRequest(
-                    this.BulkRequest.Request,
+                new SystemForCrossDomainIdentityManagementRequest<IResourceIdentifier>(
+                    this.BulkRequest.HttpContext,
                     resourceIdentifier.Identifier,
                     this.BulkRequest.CorrelationIdentifier,
                     this.BulkRequest.Extensions);
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkRequest.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkRequest.cs
deleted file mode 100644
index 9921867c..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkRequest.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-    using System.Net.Http;
-
-        public sealed class BulkRequest : SystemForCrossDomainIdentityManagementRequest<BulkRequest2>
-    {
-        public BulkRequest(
-            HttpRequestMessage request,
-            BulkRequest2 payload,
-            string correlationIdentifier,
-            IReadOnlyCollection<IExtension> extensions)
-            : base(request, payload, correlationIdentifier, extensions)
-        {
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkUpdateOperationState.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkUpdateOperationState.cs
index 52aa3ca8..79195e8a 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkUpdateOperationState.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/BulkUpdateOperationState.cs
@@ -36,7 +36,7 @@ public BulkUpdateOperationState(
         }
 
         public IReadOnlyCollection<IBulkCreationOperationContext> Dependencies => this.dependenciesWrapper;
-        
+
         public IBulkCreationOperationContext Parent
         {
             get;
@@ -140,8 +140,8 @@ public override bool TryPrepareRequest(out IRequest<IPatch> request)
                     PatchRequest = patchRequest
                 };
             IRequest<IPatch> requestBuffer =
-                new UpdateRequest(
-                    this.BulkRequest.Request,
+                new SystemForCrossDomainIdentityManagementRequest<IPatch>(
+                    this.BulkRequest.HttpContext,
                     patch,
                     this.BulkRequest.CorrelationIdentifier,
                     this.BulkRequest.Extensions);
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/BulkRequestController.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/BulkRequestController.cs
index 39481f64..7d564c1c 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/BulkRequestController.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/BulkRequestController.cs
@@ -5,13 +5,12 @@
 namespace Microsoft.SCIM
 {
     using Microsoft.AspNetCore.Authorization;
+    using Microsoft.AspNetCore.Http;
     using Microsoft.AspNetCore.Mvc;
     using System;
     using System.Collections.Generic;
     using System.Net;
-    using System.Net.Http;
     using System.Threading.Tasks;
-    using System.Web.Http;
 
     [Route(ServiceConstants.RouteBulk)]
     [Authorize]
@@ -23,34 +22,34 @@ public BulkRequestController(IProvider provider, IMonitor monitor)
         {
         }
 
-        public async Task<BulkResponse2> Post([FromBody] BulkRequest2 bulkRequest)
+        public async Task<ActionResult<BulkResponse2>> Post([FromBody] BulkRequest2 bulkRequest)
         {
             string correlationIdentifier = null;
 
             try
             {
-                HttpRequestMessage request = this.ConvertRequest();
+                HttpContext httpContext = this.HttpContext;
                 if (null == bulkRequest)
                 {
-                    throw new HttpResponseException(HttpStatusCode.BadRequest);
+                    return this.BadRequest();
                 }
 
-                if (!request.TryGetRequestIdentifier(out correlationIdentifier))
+                if (!httpContext.TryGetRequestIdentifier(out correlationIdentifier))
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
                 IProvider provider = this.provider;
                 if (null == provider)
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
                 IReadOnlyCollection<IExtension> extensions = provider.ReadExtensions();
-                IRequest<BulkRequest2> request2 = new BulkRequest(request, bulkRequest, correlationIdentifier, extensions);
+                IRequest<BulkRequest2> request2 = new SystemForCrossDomainIdentityManagementRequest<BulkRequest2>(httpContext, bulkRequest, correlationIdentifier, extensions);
                 BulkResponse2 result = await provider.ProcessAsync(request2).ConfigureAwait(false);
                 return result;
-                
+
             }
             catch (ArgumentException argumentException)
             {
@@ -64,7 +63,7 @@ public async Task<BulkResponse2> Post([FromBody] BulkRequest2 bulkRequest)
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                return this.BadRequest();
             }
             catch (NotImplementedException notImplementedException)
             {
@@ -77,7 +76,7 @@ public async Task<BulkResponse2> Post([FromBody] BulkRequest2 bulkRequest)
                             ServiceNotificationIdentifiers.BulkRequest2ControllerPostNotImplementedException);
                     monitor.Report(notification);
                 }
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
             }
             catch (NotSupportedException notSupportedException)
             {
@@ -91,7 +90,7 @@ public async Task<BulkResponse2> Post([FromBody] BulkRequest2 bulkRequest)
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
             }
             catch (Exception exception)
             {
@@ -105,7 +104,7 @@ public async Task<BulkResponse2> Post([FromBody] BulkRequest2 bulkRequest)
                     monitor.Report(notification);
                 }
 
-                throw;
+                return this.StatusCode((int)HttpStatusCode.InternalServerError);
             }
         }
     }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ControllerTemplate.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ControllerTemplate.cs
index 9a656267..f846fee8 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ControllerTemplate.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ControllerTemplate.cs
@@ -6,11 +6,9 @@ namespace Microsoft.SCIM
     using System.Collections.Generic;
     using System.Linq;
     using System.Net;
-    using System.Net.Http;
     using System.Threading.Tasks;
-    using System.Web.Http;
     using Microsoft.AspNetCore.Mvc;
-    using Microsoft.AspNetCore.Mvc.WebApiCompatShim;
+    using Microsoft.AspNetCore.Http;
 
     public abstract class ControllerTemplate : ControllerBase
     {
@@ -42,7 +40,7 @@ protected virtual void ConfigureResponse(Resource resource)
                 this.Response.Headers.Add(ControllerTemplate.HeaderKeyContentType, ProtocolConstants.ContentType);
             }
 
-            Uri baseResourceIdentifier = this.ConvertRequest().GetBaseResourceIdentifier();
+            Uri baseResourceIdentifier = this.HttpContext.GetBaseResourceIdentifier();
             Uri resourceIdentifier = resource.GetResourceIdentifier(baseResourceIdentifier);
             string resourceLocation = resourceIdentifier.AbsoluteUri;
             if (!this.Response.Headers.ContainsKey(ControllerTemplate.HeaderKeyLocation))
@@ -51,17 +49,14 @@ protected virtual void ConfigureResponse(Resource resource)
             }
         }
 
-        protected HttpRequestMessage ConvertRequest()
-        {
-            HttpRequestMessageFeature hreqmf = new HttpRequestMessageFeature(this.HttpContext);
-            HttpRequestMessage result = hreqmf.HttpRequestMessage;
-            return result;
-        }
-
         protected ObjectResult ScimError(HttpStatusCode httpStatusCode, string message)
         {
             return StatusCode((int)httpStatusCode, new Core2Error(message, (int)httpStatusCode));
         }
+        protected ObjectResult ScimError(HttpStatusCode httpStatusCode, string message, ErrorType errorType)
+        {
+            return StatusCode((int)httpStatusCode, new Core2Error(message, (int)httpStatusCode, Enum.GetName(errorType)));
+        }
 
         protected virtual bool TryGetMonitor(out IMonitor monitor)
         {
@@ -103,14 +98,14 @@ public virtual async Task<IActionResult> Delete(string identifier)
                 }
 
                 identifier = Uri.UnescapeDataString(identifier);
-                HttpRequestMessage request = this.ConvertRequest();
-                if (!request.TryGetRequestIdentifier(out correlationIdentifier))
+                HttpContext httpContext = this.HttpContext;
+                if (!httpContext.TryGetRequestIdentifier(out correlationIdentifier))
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.NotImplemented);
                 }
 
                 IProviderAdapter<T> provider = this.AdaptProvider();
-                await provider.Delete(request, identifier, correlationIdentifier).ConfigureAwait(false);
+                await provider.Delete(httpContext, identifier, correlationIdentifier).ConfigureAwait(false);
                 return this.NoContent();
             }
             catch (ArgumentException argumentException)
@@ -125,16 +120,25 @@ public virtual async Task<IActionResult> Delete(string identifier)
                     monitor.Report(notification);
                 }
 
-                return this.BadRequest();
+                return this.ScimError(HttpStatusCode.BadRequest, argumentException.Message);
             }
-            catch (HttpResponseException responseException)
+            catch (CustomHttpResponseException responseException)
             {
-                if (responseException.Response?.StatusCode == HttpStatusCode.NotFound)
+                if (responseException?.StatusCode == HttpStatusCode.NotFound)
                 {
                     return this.NotFound();
                 }
+                if (this.TryGetMonitor(out IMonitor monitor))
+                {
+                    IExceptionNotification notification =
+                        ExceptionNotificationFactory.Instance.CreateNotification(
+                            responseException.InnerException ?? responseException,
+                            correlationIdentifier,
+                            ServiceNotificationIdentifiers.ControllerTemplateGetException);
+                    monitor.Report(notification);
+                }
 
-                throw;
+                return this.ScimError(HttpStatusCode.InternalServerError, responseException.Message);
             }
             catch (NotImplementedException notImplementedException)
             {
@@ -148,7 +152,7 @@ public virtual async Task<IActionResult> Delete(string identifier)
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
             }
             catch (NotSupportedException notSupportedException)
             {
@@ -162,7 +166,21 @@ public virtual async Task<IActionResult> Delete(string identifier)
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
+            }
+            catch (ScimTypeException scimException)
+            {
+                if (this.TryGetMonitor(out IMonitor monitor))
+                {
+                    IExceptionNotification notification =
+                        ExceptionNotificationFactory.Instance.CreateNotification(
+                            scimException,
+                            correlationIdentifier,
+                            ServiceNotificationIdentifiers.ControllerTemplateDeleteNotSupportedException);
+                    monitor.Report(notification);
+                }
+
+                return this.ScimError(HttpStatusCode.BadRequest, scimException.Message, scimException.ErrorType);
             }
             catch (Exception exception)
             {
@@ -176,36 +194,39 @@ public virtual async Task<IActionResult> Delete(string identifier)
                     monitor.Report(notification);
                 }
 
-                throw;
+                return this.ScimError(HttpStatusCode.InternalServerError, exception.Message);
             }
         }
 
         [HttpGet]
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Get", Justification = "The names of the methods of a controller must correspond to the names of hypertext markup verbs")]
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords",
+            MessageId = "Get",
+            Justification =
+                "The names of the methods of a controller must correspond to the names of hypertext markup verbs")]
         public virtual async Task<ActionResult<QueryResponseBase>> Get()
         {
             string correlationIdentifier = null;
             try
             {
-                HttpRequestMessage request = this.ConvertRequest();
-                if (!request.TryGetRequestIdentifier(out correlationIdentifier))
+                HttpContext httpContext = this.HttpContext;
+                if (!httpContext.TryGetRequestIdentifier(out correlationIdentifier))
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
-                IResourceQuery resourceQuery = new ResourceQuery(request.RequestUri);
+                IResourceQuery resourceQuery = new ResourceQuery(HttpContext);
                 IProviderAdapter<T> provider = this.AdaptProvider();
                 QueryResponseBase result =
                     await provider
-                            .Query(
-                                request,
-                                resourceQuery.Filters,
-                                resourceQuery.Attributes,
-                                resourceQuery.ExcludedAttributes,
-                                resourceQuery.PaginationParameters,
-                                correlationIdentifier)
-                            .ConfigureAwait(false);
-                return this.Ok(result);
+                        .Query(
+                            httpContext,
+                            resourceQuery.Filters,
+                            resourceQuery.Attributes,
+                            resourceQuery.ExcludedAttributes,
+                            resourceQuery.PaginationParameters,
+                            correlationIdentifier)
+                        .ConfigureAwait(false);
+                return result;
             }
             catch (ArgumentException argumentException)
             {
@@ -249,9 +270,23 @@ await provider
 
                 return this.ScimError(HttpStatusCode.BadRequest, notSupportedException.Message);
             }
-            catch (HttpResponseException responseException)
+            catch (ScimTypeException scimException)
+            {
+                if (this.TryGetMonitor(out IMonitor monitor))
+                {
+                    IExceptionNotification notification =
+                        ExceptionNotificationFactory.Instance.CreateNotification(
+                            scimException,
+                            correlationIdentifier,
+                            ServiceNotificationIdentifiers.ControllerTemplateDeleteNotSupportedException);
+                    monitor.Report(notification);
+                }
+
+                return this.ScimError(HttpStatusCode.BadRequest, scimException.Message, scimException.ErrorType);
+            }
+            catch (CustomHttpResponseException responseException)
             {
-                if (responseException.Response?.StatusCode != HttpStatusCode.NotFound)
+                if (responseException?.StatusCode != HttpStatusCode.NotFound)
                 {
                     if (this.TryGetMonitor(out IMonitor monitor))
                     {
@@ -283,38 +318,43 @@ await provider
         }
 
         [HttpGet(ControllerTemplate.AttributeValueIdentifier)]
-        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Get", Justification = "The names of the methods of a controller must correspond to the names of hypertext markup verbs")]
-        public virtual async Task<IActionResult> Get([FromUri]string identifier)
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords",
+            MessageId = "Get",
+            Justification =
+                "The names of the methods of a controller must correspond to the names of hypertext markup verbs")]
+        public virtual async Task<ActionResult<Resource>> Get([FromRoute] string identifier)
         {
             string correlationIdentifier = null;
             try
             {
                 if (string.IsNullOrWhiteSpace(identifier))
                 {
-                    return this.ScimError(HttpStatusCode.BadRequest, SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidIdentifier);
+                    return this.ScimError(HttpStatusCode.BadRequest,
+                        SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidIdentifier);
                 }
 
-                HttpRequestMessage request = this.ConvertRequest();
-                if (!request.TryGetRequestIdentifier(out correlationIdentifier))
+                HttpContext httpContext = this.HttpContext;
+                if (!httpContext.TryGetRequestIdentifier(out correlationIdentifier))
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
-                IResourceQuery resourceQuery = new ResourceQuery(request.RequestUri);
+                IResourceQuery resourceQuery = new ResourceQuery(HttpContext);
                 if (resourceQuery.Filters.Any())
                 {
                     if (resourceQuery.Filters.Count != 1)
                     {
-                        return this.ScimError(HttpStatusCode.BadRequest, SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterCount);
+                        return this.ScimError(HttpStatusCode.BadRequest,
+                            SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterCount);
                     }
 
                     IFilter filter = new Filter(AttributeNames.Identifier, ComparisonOperator.Equals, identifier);
                     filter.AdditionalFilter = resourceQuery.Filters.Single();
                     IReadOnlyCollection<IFilter> filters =
                         new IFilter[]
-                            {
-                                filter
-                            };
+                        {
+                            filter
+                        };
                     IResourceQuery effectiveQuery =
                         new ResourceQuery(
                             filters,
@@ -324,7 +364,7 @@ public virtual async Task<IActionResult> Get([FromUri]string identifier)
                     QueryResponseBase queryResponse =
                         await provider
                             .Query(
-                                request,
+                                httpContext,
                                 effectiveQuery.Filters,
                                 effectiveQuery.Attributes,
                                 effectiveQuery.ExcludedAttributes,
@@ -333,7 +373,10 @@ await provider
                             .ConfigureAwait(false);
                     if (!queryResponse.Resources.Any())
                     {
-                        return this.ScimError(HttpStatusCode.NotFound, string.Format(SystemForCrossDomainIdentityManagementServiceResources.ResourceNotFoundTemplate, identifier));
+                        return this.ScimError(HttpStatusCode.NotFound,
+                            string.Format(
+                                SystemForCrossDomainIdentityManagementServiceResources.ResourceNotFoundTemplate,
+                                identifier));
                     }
 
                     Resource result = queryResponse.Resources.Single();
@@ -345,7 +388,7 @@ await provider
                     Resource result =
                         await provider
                             .Retrieve(
-                                request,
+                                httpContext,
                                 identifier,
                                 resourceQuery.Attributes,
                                 resourceQuery.ExcludedAttributes,
@@ -353,10 +396,13 @@ await provider
                             .ConfigureAwait(false);
                     if (null == result)
                     {
-                        return this.ScimError(HttpStatusCode.NotFound, string.Format(SystemForCrossDomainIdentityManagementServiceResources.ResourceNotFoundTemplate, identifier));
+                        return this.ScimError(HttpStatusCode.NotFound,
+                            string.Format(
+                                SystemForCrossDomainIdentityManagementServiceResources.ResourceNotFoundTemplate,
+                                identifier));
                     }
 
-                    return this.Ok(result);
+                    return result;
                 }
             }
             catch (ArgumentException argumentException)
@@ -401,9 +447,23 @@ await provider
 
                 return this.ScimError(HttpStatusCode.BadRequest, notSupportedException.Message);
             }
-            catch (HttpResponseException responseException)
+            catch (ScimTypeException scimException)
+            {
+                if (this.TryGetMonitor(out IMonitor monitor))
+                {
+                    IExceptionNotification notification =
+                        ExceptionNotificationFactory.Instance.CreateNotification(
+                            scimException,
+                            correlationIdentifier,
+                            ServiceNotificationIdentifiers.ControllerTemplateDeleteNotSupportedException);
+                    monitor.Report(notification);
+                }
+
+                return this.ScimError(HttpStatusCode.BadRequest, scimException.Message, scimException.ErrorType);
+            }
+            catch (CustomHttpResponseException responseException)
             {
-                if (responseException.Response?.StatusCode != HttpStatusCode.NotFound)
+                if (responseException?.StatusCode != HttpStatusCode.NotFound)
                 {
                     if (this.TryGetMonitor(out IMonitor monitor))
                     {
@@ -416,9 +476,11 @@ await provider
                     }
                 }
 
-                if (responseException.Response?.StatusCode == HttpStatusCode.NotFound)
+                if (responseException?.StatusCode == HttpStatusCode.NotFound)
                 {
-                    return this.ScimError(HttpStatusCode.NotFound, string.Format(SystemForCrossDomainIdentityManagementServiceResources.ResourceNotFoundTemplate, identifier));
+                    return this.ScimError(HttpStatusCode.NotFound,
+                        string.Format(SystemForCrossDomainIdentityManagementServiceResources.ResourceNotFoundTemplate,
+                            identifier));
                 }
 
                 return this.ScimError(HttpStatusCode.InternalServerError, responseException.Message);
@@ -440,7 +502,8 @@ await provider
         }
 
         [HttpPatch(ControllerTemplate.AttributeValueIdentifier)]
-        public virtual async Task<IActionResult> Patch(string identifier, [FromBody]PatchRequest2 patchRequest)
+        public virtual async Task<ActionResult<Resource>> Patch(string identifier,
+            [FromBody] PatchRequest2 patchRequest)
         {
             string correlationIdentifier = null;
 
@@ -458,14 +521,15 @@ public virtual async Task<IActionResult> Patch(string identifier, [FromBody]Patc
                     return this.BadRequest();
                 }
 
-                HttpRequestMessage request = this.ConvertRequest();
-                if (!request.TryGetRequestIdentifier(out correlationIdentifier))
+                HttpContext httpContext = this.HttpContext;
+                if (!httpContext.TryGetRequestIdentifier(out correlationIdentifier))
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
                 IProviderAdapter<T> provider = this.AdaptProvider();
-                await provider.Update(request, identifier, patchRequest, correlationIdentifier).ConfigureAwait(false);
+                await provider.Update(httpContext, identifier, patchRequest, correlationIdentifier)
+                    .ConfigureAwait(false);
 
                 // If EnterpriseUser, return HTTP code 200 and user object, otherwise HTTP code 204
                 if (provider.SchemaIdentifier == SchemaIdentifiers.Core2EnterpriseUser)
@@ -487,7 +551,7 @@ public virtual async Task<IActionResult> Patch(string identifier, [FromBody]Patc
                     monitor.Report(notification);
                 }
 
-                return this.BadRequest();
+                return this.ScimError(HttpStatusCode.BadRequest, argumentException.Message);
             }
             catch (NotImplementedException notImplementedException)
             {
@@ -501,7 +565,7 @@ public virtual async Task<IActionResult> Patch(string identifier, [FromBody]Patc
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return StatusCode((int)HttpStatusCode.NotImplemented);
             }
             catch (NotSupportedException notSupportedException)
             {
@@ -515,11 +579,25 @@ public virtual async Task<IActionResult> Patch(string identifier, [FromBody]Patc
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
+            }
+            catch (ScimTypeException scimException)
+            {
+                if (this.TryGetMonitor(out IMonitor monitor))
+                {
+                    IExceptionNotification notification =
+                        ExceptionNotificationFactory.Instance.CreateNotification(
+                            scimException,
+                            correlationIdentifier,
+                            ServiceNotificationIdentifiers.ControllerTemplateDeleteNotSupportedException);
+                    monitor.Report(notification);
+                }
+
+                return this.ScimError(scimException.ErrorType == ErrorType.uniqueness ? HttpStatusCode.Conflict : HttpStatusCode.BadRequest, scimException.Message, scimException.ErrorType);
             }
-            catch (HttpResponseException responseException)
+            catch (CustomHttpResponseException responseException)
             {
-                if (responseException.Response?.StatusCode == HttpStatusCode.NotFound)
+                if (responseException?.StatusCode == HttpStatusCode.NotFound)
                 {
                     return this.NotFound();
                 }
@@ -536,8 +614,7 @@ public virtual async Task<IActionResult> Patch(string identifier, [FromBody]Patc
                     }
                 }
 
-                throw;
-
+                return this.ScimError(responseException.StatusCode, responseException.Message);
             }
             catch (Exception exception)
             {
@@ -551,12 +628,12 @@ public virtual async Task<IActionResult> Patch(string identifier, [FromBody]Patc
                     monitor.Report(notification);
                 }
 
-                throw;
+                return this.StatusCode((int)HttpStatusCode.InternalServerError);
             }
         }
 
         [HttpPost]
-        public virtual async Task<ActionResult<Resource>> Post([FromBody]T resource)
+        public virtual async Task<ActionResult<Resource>> Post([FromBody] T resource)
         {
             string correlationIdentifier = null;
 
@@ -567,14 +644,15 @@ public virtual async Task<ActionResult<Resource>> Post([FromBody]T resource)
                     return this.BadRequest();
                 }
 
-                HttpRequestMessage request = this.ConvertRequest();
-                if (!request.TryGetRequestIdentifier(out correlationIdentifier))
+                HttpContext httpContext = this.HttpContext;
+                if (!httpContext.TryGetRequestIdentifier(out correlationIdentifier))
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
                 IProviderAdapter<T> provider = this.AdaptProvider();
-                Resource result = await provider.Create(request, resource, correlationIdentifier).ConfigureAwait(false);
+                Resource result = await provider.Create(httpContext, resource, correlationIdentifier)
+                    .ConfigureAwait(false);
                 this.ConfigureResponse(result);
                 return this.CreatedAtAction(nameof(Post), result);
             }
@@ -590,7 +668,7 @@ public virtual async Task<ActionResult<Resource>> Post([FromBody]T resource)
                     monitor.Report(notification);
                 }
 
-                return this.BadRequest();
+                return this.ScimError(HttpStatusCode.BadRequest, argumentException.Message);;
             }
             catch (NotImplementedException notImplementedException)
             {
@@ -604,7 +682,7 @@ public virtual async Task<ActionResult<Resource>> Post([FromBody]T resource)
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
             }
             catch (NotSupportedException notSupportedException)
             {
@@ -618,9 +696,23 @@ public virtual async Task<ActionResult<Resource>> Post([FromBody]T resource)
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
+            }
+            catch (ScimTypeException scimException)
+            {
+                if (this.TryGetMonitor(out IMonitor monitor))
+                {
+                    IExceptionNotification notification =
+                        ExceptionNotificationFactory.Instance.CreateNotification(
+                            scimException,
+                            correlationIdentifier,
+                            ServiceNotificationIdentifiers.ControllerTemplateDeleteNotSupportedException);
+                    monitor.Report(notification);
+                }
+
+                return this.ScimError(scimException.ErrorType == ErrorType.uniqueness ? HttpStatusCode.Conflict : HttpStatusCode.BadRequest, scimException.Message, scimException.ErrorType);
             }
-            catch (HttpResponseException httpResponseException)
+            catch (CustomHttpResponseException httpResponseException)
             {
                 if (this.TryGetMonitor(out IMonitor monitor))
                 {
@@ -632,10 +724,11 @@ public virtual async Task<ActionResult<Resource>> Post([FromBody]T resource)
                     monitor.Report(notification);
                 }
 
-                if (httpResponseException.Response.StatusCode == HttpStatusCode.Conflict)
-                    return this.Conflict();
+                if (httpResponseException.StatusCode == HttpStatusCode.Conflict)
+                    return this.ScimError(HttpStatusCode.Conflict,
+                        SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
                 else
-                    return this.BadRequest();
+                    return this.ScimError(HttpStatusCode.BadRequest, httpResponseException.Message);
             }
             catch (Exception exception)
             {
@@ -649,12 +742,12 @@ public virtual async Task<ActionResult<Resource>> Post([FromBody]T resource)
                     monitor.Report(notification);
                 }
 
-                throw;
+                return this.StatusCode((int)HttpStatusCode.InternalServerError);
             }
         }
 
         [HttpPut(ControllerTemplate.AttributeValueIdentifier)]
-        public virtual async Task<ActionResult<Resource>> Put([FromBody]T resource, string identifier)
+        public virtual async Task<ActionResult<Resource>> Put([FromBody] T resource, string identifier)
         {
             string correlationIdentifier = null;
 
@@ -662,22 +755,25 @@ public virtual async Task<ActionResult<Resource>> Put([FromBody]T resource, stri
             {
                 if (null == resource)
                 {
-                    return this.ScimError(HttpStatusCode.BadRequest, SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidResource);
+                    return this.ScimError(HttpStatusCode.BadRequest,
+                        SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidResource);
                 }
 
                 if (string.IsNullOrEmpty(identifier))
                 {
-                    return this.ScimError(HttpStatusCode.BadRequest, SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidIdentifier);
+                    return this.ScimError(HttpStatusCode.BadRequest,
+                        SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidIdentifier);
                 }
 
-                HttpRequestMessage request = this.ConvertRequest();
-                if (!request.TryGetRequestIdentifier(out correlationIdentifier))
+                HttpContext httpContext = this.HttpContext;
+                if (!httpContext.TryGetRequestIdentifier(out correlationIdentifier))
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
                 IProviderAdapter<T> provider = this.AdaptProvider();
-                Resource result = await provider.Replace(request, resource, correlationIdentifier).ConfigureAwait(false);
+                Resource result = await provider.Replace(httpContext, resource, correlationIdentifier)
+                    .ConfigureAwait(false);
                 this.ConfigureResponse(result);
                 return this.Ok(result);
             }
@@ -723,7 +819,21 @@ public virtual async Task<ActionResult<Resource>> Put([FromBody]T resource, stri
 
                 return this.ScimError(HttpStatusCode.BadRequest, notSupportedException.Message);
             }
-            catch (HttpResponseException httpResponseException)
+            catch (ScimTypeException scimException)
+            {
+                if (this.TryGetMonitor(out IMonitor monitor))
+                {
+                    IExceptionNotification notification =
+                        ExceptionNotificationFactory.Instance.CreateNotification(
+                            scimException,
+                            correlationIdentifier,
+                            ServiceNotificationIdentifiers.ControllerTemplateDeleteNotSupportedException);
+                    monitor.Report(notification);
+                }
+
+                return this.ScimError(scimException.ErrorType == ErrorType.uniqueness ? HttpStatusCode.Conflict : HttpStatusCode.BadRequest, scimException.Message, scimException.ErrorType);
+            }
+            catch (CustomHttpResponseException httpResponseException)
             {
                 if (this.TryGetMonitor(out IMonitor monitor))
                 {
@@ -735,10 +845,13 @@ public virtual async Task<ActionResult<Resource>> Put([FromBody]T resource, stri
                     monitor.Report(notification);
                 }
 
-                if (httpResponseException.Response.StatusCode == HttpStatusCode.NotFound)
-                    return this.ScimError(HttpStatusCode.NotFound, string.Format(SystemForCrossDomainIdentityManagementServiceResources.ResourceNotFoundTemplate, identifier));
-                else if (httpResponseException.Response.StatusCode == HttpStatusCode.Conflict)
-                    return this.ScimError(HttpStatusCode.Conflict, SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
+                if (httpResponseException.StatusCode == HttpStatusCode.NotFound)
+                    return this.ScimError(HttpStatusCode.NotFound,
+                        string.Format(SystemForCrossDomainIdentityManagementServiceResources.ResourceNotFoundTemplate,
+                            identifier));
+                else if (httpResponseException.StatusCode == HttpStatusCode.Conflict)
+                    return this.ScimError(HttpStatusCode.Conflict,
+                        SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
                 else
                     return this.ScimError(HttpStatusCode.BadRequest, httpResponseException.Message);
             }
@@ -754,7 +867,7 @@ public virtual async Task<ActionResult<Resource>> Put([FromBody]T resource, stri
                     monitor.Report(notification);
                 }
 
-                return this.ScimError(HttpStatusCode.InternalServerError, exception.Message);
+                return this.StatusCode((int)HttpStatusCode.InternalServerError);
             }
         }
     }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ResourceTypesController.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ResourceTypesController.cs
index ed5aa50a..46dce6dc 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ResourceTypesController.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ResourceTypesController.cs
@@ -5,9 +5,8 @@ namespace Microsoft.SCIM
     using System;
     using System.Collections.Generic;
     using System.Net;
-    using System.Net.Http;
-    using System.Web.Http;
     using Microsoft.AspNetCore.Authorization;
+    using Microsoft.AspNetCore.Http;
     using Microsoft.AspNetCore.Mvc;
 
     [Route(ServiceConstants.RouteResourceTypes)]
@@ -20,22 +19,22 @@ public ResourceTypesController(IProvider provider, IMonitor monitor)
         {
         }
 
-        public QueryResponseBase Get()
+        public ActionResult<QueryResponseBase> Get()
         {
             string correlationIdentifier = null;
 
             try
             {
-                HttpRequestMessage request = this.ConvertRequest();
-                if (!request.TryGetRequestIdentifier(out correlationIdentifier))
+                HttpContext httpContext = this.HttpContext;
+                if (!httpContext.TryGetRequestIdentifier(out correlationIdentifier))
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
                 IProvider provider = this.provider;
                 if (null == provider)
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
                 IReadOnlyCollection<Resource> resources = provider.ResourceTypes;
@@ -45,7 +44,7 @@ public QueryResponseBase Get()
                     result.ItemsPerPage =
                         resources.Count;
                 result.StartIndex = 1;
-                return result;
+                return this.Ok(result);
 
             }
             catch (ArgumentException argumentException)
@@ -59,8 +58,7 @@ public QueryResponseBase Get()
                             ServiceNotificationIdentifiers.ResourceTypesControllerGetArgumentException);
                     monitor.Report(notification);
                 }
-
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                return this.BadRequest();
             }
             catch (NotImplementedException notImplementedException)
             {
@@ -74,7 +72,7 @@ public QueryResponseBase Get()
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
             }
             catch (NotSupportedException notSupportedException)
             {
@@ -88,7 +86,7 @@ public QueryResponseBase Get()
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
             }
             catch (Exception exception)
             {
@@ -102,7 +100,7 @@ public QueryResponseBase Get()
                     monitor.Report(notification);
                 }
 
-                throw;
+                return this.StatusCode((int)HttpStatusCode.InternalServerError);
             }
         }
     }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/SchemasController.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/SchemasController.cs
index 811784ec..9c29b481 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/SchemasController.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/SchemasController.cs
@@ -5,9 +5,8 @@ namespace Microsoft.SCIM
     using System;
     using System.Collections.Generic;
     using System.Net;
-    using System.Net.Http;
-    using System.Web.Http;
     using Microsoft.AspNetCore.Authorization;
+    using Microsoft.AspNetCore.Http;
     using Microsoft.AspNetCore.Mvc;
 
     [Route(ServiceConstants.RouteSchemas)]
@@ -20,33 +19,33 @@ public SchemasController(IProvider provider, IMonitor monitor)
         {
         }
 
-        public QueryResponseBase Get()
+        public ActionResult<QueryResponseBase> Get()
         {
             string correlationIdentifier = null;
 
             try
             {
-                HttpRequestMessage request = this.ConvertRequest();
-                if (!request.TryGetRequestIdentifier(out correlationIdentifier))
+                HttpContext httpContext = this.HttpContext;
+                if (!httpContext.TryGetRequestIdentifier(out correlationIdentifier))
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
                 IProvider provider = this.provider;
                 if (null == provider)
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int)HttpStatusCode.InternalServerError);
                 }
 
                 IReadOnlyCollection<Resource> resources = provider.Schema;
                 QueryResponseBase result = new QueryResponse(resources);
-                
+
                 result.TotalResults =
                     result.ItemsPerPage =
                         resources.Count;
                 result.StartIndex = 1;
                 return result;
-                
+
             }
             catch (ArgumentException argumentException)
             {
@@ -60,7 +59,7 @@ public QueryResponseBase Get()
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                return BadRequest();
             }
             catch (NotImplementedException notImplementedException)
             {
@@ -74,7 +73,7 @@ public QueryResponseBase Get()
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
             }
             catch (NotSupportedException notSupportedException)
             {
@@ -88,7 +87,7 @@ public QueryResponseBase Get()
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int)HttpStatusCode.NotImplemented);
             }
             catch (Exception exception)
             {
@@ -102,7 +101,7 @@ public QueryResponseBase Get()
                     monitor.Report(notification);
                 }
 
-                throw;
+                return this.StatusCode((int)HttpStatusCode.InternalServerError);
             }
         }
     }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ServiceProviderConfigurationController.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ServiceProviderConfigurationController.cs
index eb803f24..31cb3adf 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ServiceProviderConfigurationController.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Controllers/ServiceProviderConfigurationController.cs
@@ -4,9 +4,8 @@ namespace Microsoft.SCIM
 {
     using System;
     using System.Net;
-    using System.Net.Http;
-    using System.Web.Http;
     using Microsoft.AspNetCore.Authorization;
+    using Microsoft.AspNetCore.Http;
     using Microsoft.AspNetCore.Mvc;
 
     [Route(ServiceConstants.RouteServiceConfiguration)]
@@ -19,22 +18,22 @@ public ServiceProviderConfigurationController(IProvider provider, IMonitor monit
         {
         }
 
-        public ServiceConfigurationBase Get()
+        public ActionResult<ServiceConfigurationBase> Get()
         {
             string correlationIdentifier = null;
 
             try
             {
-                HttpRequestMessage request = this.ConvertRequest();
-                if (!request.TryGetRequestIdentifier(out correlationIdentifier))
+                HttpContext httpContext = this.HttpContext;
+                if (!httpContext.TryGetRequestIdentifier(out correlationIdentifier))
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int) HttpStatusCode.InternalServerError);
                 }
 
                 IProvider provider = this.provider;
                 if (null == provider)
                 {
-                    throw new HttpResponseException(HttpStatusCode.InternalServerError);
+                    return this.StatusCode((int) HttpStatusCode.InternalServerError);
                 }
 
                 ServiceConfigurationBase result = provider.Configuration;
@@ -52,7 +51,7 @@ public ServiceConfigurationBase Get()
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                return this.BadRequest();
             }
             catch (NotImplementedException notImplementedException)
             {
@@ -66,7 +65,7 @@ public ServiceConfigurationBase Get()
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int) HttpStatusCode.NotImplemented);
             }
             catch (NotSupportedException notSupportedException)
             {
@@ -80,7 +79,7 @@ public ServiceConfigurationBase Get()
                     monitor.Report(notification);
                 }
 
-                throw new HttpResponseException(HttpStatusCode.NotImplemented);
+                return this.StatusCode((int) HttpStatusCode.NotImplemented);
             }
             catch (Exception exception)
             {
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/CreationRequest.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/CreationRequest.cs
deleted file mode 100644
index 5fe83f01..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/CreationRequest.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-    using System.Net.Http;
-
-    public sealed class CreationRequest : SystemForCrossDomainIdentityManagementRequest<Resource>
-    {
-        public CreationRequest(
-            HttpRequestMessage request,
-            Resource payload,
-            string correlationIdentifier,
-            IReadOnlyCollection<IExtension> extensions)
-            : base(request, payload, correlationIdentifier, extensions)
-        {
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/DeletionRequest.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/DeletionRequest.cs
deleted file mode 100644
index 7a43740f..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/DeletionRequest.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-    using System.Net.Http;
-
-    public sealed class DeletionRequest :
-        SystemForCrossDomainIdentityManagementRequest<IResourceIdentifier>
-    {
-        public DeletionRequest(
-            HttpRequestMessage request,
-            IResourceIdentifier payload,
-            string correlationIdentifier,
-            IReadOnlyCollection<IExtension> extensions)
-            : base(request, payload, correlationIdentifier, extensions)
-        {
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/DependencyResolverDecorator.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/DependencyResolverDecorator.cs
deleted file mode 100644
index ea0a9b98..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/DependencyResolverDecorator.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-//namespace Microsoft.SCIM
-//{
-//    using System;
-//    using System.Collections.Generic;
-//    using System.Web.Http.Dependencies;
-
-//    internal abstract class DependencyResolverDecorator : IDependencyResolver
-//    {
-//        private const string ArgumentNameInnerResolver = "innerResolver";
-//        private const string ArgumentNameServiceType = "serviceType";
-
-//        private readonly object thisLock = new object();
-
-//        protected DependencyResolverDecorator(IDependencyResolver innerResolver)
-//        {
-//            this.InnerResolver = innerResolver ?? throw new ArgumentNullException(DependencyResolverDecorator.ArgumentNameInnerResolver);
-//        }
-
-//        public IDependencyResolver InnerResolver
-//        {
-//            get;
-//            set;
-//        }
-
-//        public virtual IDependencyScope BeginScope()
-//        {
-//            IDependencyScope result = this.InnerResolver.BeginScope();
-//            return result;
-//        }
-
-//        public void Dispose()
-//        {
-//            this.Dispose(true);
-//            GC.SuppressFinalize(this);
-//        }
-
-//        protected virtual void Dispose(bool disposing)
-//        {
-//            if (disposing)
-//            {
-//                if (this.InnerResolver != null)
-//                {
-//                    lock (this.thisLock)
-//                    {
-//                        if (this.InnerResolver != null)
-//                        {
-//                            this.InnerResolver.Dispose();
-//                            this.InnerResolver = null;
-//                        }
-//                    }
-//                }
-//            }
-//        }
-
-//        public virtual object GetService(Type serviceType)
-//        {
-//            if (null == serviceType)
-//            {
-//                throw new ArgumentNullException(DependencyResolverDecorator.ArgumentNameServiceType);
-//            }
-
-//            object result = this.InnerResolver.GetService(serviceType);
-//            return result;
-//        }
-
-//        public virtual IEnumerable<object> GetServices(Type serviceType)
-//        {
-//            if (null == serviceType)
-//            {
-//                throw new ArgumentNullException(DependencyResolverDecorator.ArgumentNameServiceType);
-//            }
-
-//            IEnumerable<object> results = this.InnerResolver.GetServices(serviceType);
-//            return results;
-//        }
-//    }
-//}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/DeserializingFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/DeserializingFactory.cs
deleted file mode 100644
index 7f0cc8e0..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/DeserializingFactory.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-
-    public abstract class DeserializingFactory<TResource> :
-            JsonDeserializingFactory<TResource>,
-            IResourceJsonDeserializingFactory<TResource> where TResource : Resource, new()
-    {
-        public new TResource Create(IReadOnlyDictionary<string, object> json)
-        {
-            TResource result = base.Create(json);
-            return result;
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/EventRequest.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/EventRequest.cs
deleted file mode 100644
index 0b15ec82..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/EventRequest.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-    using System.Net.Http;
-
-    public sealed class EventRequest : SystemForCrossDomainIdentityManagementRequest<IEventToken>
-    {
-        public EventRequest(
-            HttpRequestMessage request,
-            IEventToken payload,
-            string correlationIdentifier,
-            IReadOnlyCollection<IExtension> extensions)
-            : base(request, payload, correlationIdentifier, extensions)
-        {
-        }
-    }
-}
\ No newline at end of file
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Exceptions/CustomHttpResponseException.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Exceptions/CustomHttpResponseException.cs
new file mode 100644
index 00000000..8be29e5d
--- /dev/null
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Exceptions/CustomHttpResponseException.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Net;
+
+namespace Microsoft.SCIM
+{
+    public class CustomHttpResponseException : Exception
+    {
+        public HttpStatusCode StatusCode { get; private set; }
+
+        public CustomHttpResponseException(HttpStatusCode statusCode): base(GetErrorMessage(statusCode))
+        {
+            StatusCode = statusCode;
+        }
+        private static string GetErrorMessage(HttpStatusCode statusCode)
+        {
+            switch (statusCode)
+            {
+                case HttpStatusCode.BadRequest:
+                    return "Request is unparsable, syntactically incorrect, or violates schema.";
+                case HttpStatusCode.Unauthorized:
+                    return "Authorization failure. The authorization header was invalid or missing.";
+                case HttpStatusCode.Forbidden:
+                    return "Operation is not permitted based on the supplied authorization.";
+                case HttpStatusCode.NotFound:
+                    return "Specified resource (e.g., User, Group, etc.) or endpoint does not exist.";
+                case HttpStatusCode.Conflict:
+                    return "The specified version number does not match the resource's latest version number, or a service provider refused to create a new, duplicate resource.";
+                case HttpStatusCode.InternalServerError:
+                    return "The server encountered an unexpected condition which prevented it from fulfilling the request.";
+                case HttpStatusCode.NotImplemented:
+                    return "Service provider does not support the requested operation.";
+                default:
+                    return "An error occurred.";
+            }
+        }
+    }
+}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Exceptions/ScimTypeException.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Exceptions/ScimTypeException.cs
new file mode 100644
index 00000000..45d40dc8
--- /dev/null
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Exceptions/ScimTypeException.cs
@@ -0,0 +1,25 @@
+using System;
+
+namespace Microsoft.SCIM;
+
+public class ScimTypeException: Exception
+{
+    public ScimTypeException()
+    {
+    }
+
+    public ErrorType ErrorType { get; set; }
+
+    public ScimTypeException(string message): base(message)
+    {
+    }
+
+    public ScimTypeException(string message, Exception innerException): base(message, innerException)
+    {
+    }
+
+    public ScimTypeException(ErrorType errorType, string message) : base(message)
+    {
+        this.ErrorType = errorType;
+    }
+}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpResponseExceptionFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpResponseExceptionFactory.cs
deleted file mode 100644
index 74f30025..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpResponseExceptionFactory.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System.Net;
-    using System.Net.Http;
-    using System.Web.Http;
-
-    internal abstract class HttpResponseExceptionFactory<T>
-    {
-        public abstract HttpResponseMessage ProvideMessage(HttpStatusCode statusCode, T content);
-
-        public HttpResponseException CreateException(HttpStatusCode statusCode, T content)
-        {
-            HttpResponseMessage message = null;
-            try
-            {
-                message = this.ProvideMessage(statusCode, content);
-                HttpResponseException result = new HttpResponseException(message);
-                result = null;
-                return result;
-            }
-            finally
-            {
-                if (message != null)
-                {
-                    message.Dispose();
-                    message = null;
-                }
-            }
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpResponseMessageFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpResponseMessageFactory.cs
deleted file mode 100644
index 0d8b09ac..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpResponseMessageFactory.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System.Net;
-    using System.Net.Http;
-
-    internal abstract class HttpResponseMessageFactory<T>
-    {
-        public abstract HttpContent ProvideContent(T content);
-
-        public HttpResponseMessage CreateMessage(HttpStatusCode statusCode, T content)
-        {
-            HttpContent messageContent = null;
-            try
-            {
-                messageContent = this.ProvideContent(content);
-                HttpResponseMessage result = null;
-                try
-                {
-                    result = new HttpResponseMessage(statusCode);
-                    result.Content = messageContent;
-                    messageContent = null;
-                    return result;
-                }
-                catch
-                {
-                    if (result != null)
-                    {
-                        result.Dispose();
-                        result = null;
-                    };
-
-                    throw;
-                }
-            }
-            finally
-            {
-                if (messageContent != null)
-                {
-                    messageContent.Dispose();
-                    messageContent = null;
-                }
-            }
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpStringResponseExceptionFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpStringResponseExceptionFactory.cs
deleted file mode 100644
index 75e22a4a..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpStringResponseExceptionFactory.cs
+++ /dev/null
@@ -1,43 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Net;
-    using System.Net.Http;
-
-    internal class HttpStringResponseExceptionFactory : HttpResponseExceptionFactory<string>
-    {
-        private const string ArgumentNameContent = "content";
-
-        private static readonly Lazy<HttpResponseMessageFactory<string>> ResponseMessageFactory =
-            new Lazy<HttpResponseMessageFactory<string>>(
-                () =>
-                    new HttpStringResponseMessageFactory());
-
-        public override HttpResponseMessage ProvideMessage(HttpStatusCode statusCode, string content)
-        {
-            if (string.IsNullOrWhiteSpace(content))
-            {
-                throw new ArgumentNullException(HttpStringResponseExceptionFactory.ArgumentNameContent);
-            }
-
-            HttpResponseMessage result = null;
-            try
-            {
-                result = HttpStringResponseExceptionFactory.ResponseMessageFactory.Value.CreateMessage(statusCode, content);
-                return result;
-            }
-            catch
-            {
-                if (result != null)
-                {
-                    result.Dispose();
-                    result = null;
-                }
-
-                throw;
-            }
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpStringResponseMessageFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpStringResponseMessageFactory.cs
deleted file mode 100644
index 88597bfb..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/HttpStringResponseMessageFactory.cs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Net.Http;
-
-    internal class HttpStringResponseMessageFactory : HttpResponseMessageFactory<string>
-    {
-        private const string ArgumentNameContent = "content";
-
-        public override HttpContent ProvideContent(string content)
-        {
-            if (string.IsNullOrWhiteSpace(content))
-            {
-                throw new ArgumentNullException(HttpStringResponseMessageFactory.ArgumentNameContent);
-            }
-
-            HttpContent result = null;
-            try
-            {
-                result = new StringContent(content);
-                return result;
-            }
-            catch
-            {
-                if (result != null)
-                {
-                    result.Dispose();
-                    result = null;
-                }
-
-                throw;
-            }
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/IMetadataProvider.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/IMetadataProvider.cs
deleted file mode 100644
index 9bc3d43b..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/IMetadataProvider.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-
-    public interface IMetadataProvider
-    {
-        Core2ServiceConfiguration Configuration { get; }
-        IReadOnlyCollection<Core2ResourceType> ResourceTypes { get; }
-        IReadOnlyCollection<TypeScheme> Schema { get; }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/IProvider.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/IProvider.cs
index c0dd13e8..35267429 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/IProvider.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/IProvider.cs
@@ -2,11 +2,8 @@
 
 namespace Microsoft.SCIM
 {
-    using System;
     using System.Collections.Generic;
     using System.Threading.Tasks;
-    using System.Web.Http;
-    using Microsoft.AspNetCore.Builder;
 
     public interface IProvider
     {
@@ -21,12 +18,12 @@ public interface IProvider
         //Action<IApplicationBuilder, HttpConfiguration> StartupBehavior { get; }
         IResourceJsonDeserializingFactory<Core2UserBase> UserDeserializationBehavior { get; }
         Task<Resource> CreateAsync(IRequest<Resource> request);
-        Task DeleteAsync(IRequest<IResourceIdentifier> request);
+        Task<Resource> DeleteAsync(IRequest<IResourceIdentifier> request);
         Task<QueryResponseBase> PaginateQueryAsync(IRequest<IQueryParameters> request);
         Task<Resource[]> QueryAsync(IRequest<IQueryParameters> request);
         Task<Resource> ReplaceAsync(IRequest<Resource> request);
         Task<Resource> RetrieveAsync(IRequest<IResourceRetrievalParameters> request);
-        Task UpdateAsync(IRequest<IPatch> request);
+        Task<Resource> UpdateAsync(IRequest<IPatch> request);
         Task<BulkResponse2> ProcessAsync(IRequest<BulkRequest2> request);
     }
 }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/IProviderAdapter.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/IProviderAdapter.cs
index 3f835ad2..ed43706e 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/IProviderAdapter.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/IProviderAdapter.cs
@@ -2,32 +2,32 @@
 
 namespace Microsoft.SCIM
 {
+    using Microsoft.AspNetCore.Http;
     using System.Collections.Generic;
-    using System.Net.Http;
     using System.Threading.Tasks;
 
     public interface IProviderAdapter<T> where T : Resource
     {
         string SchemaIdentifier { get; }
 
-        Task<Resource> Create(HttpRequestMessage request, Resource resource, string correlationIdentifier);
-        Task Delete(HttpRequestMessage request, string identifier, string correlationIdentifier);
+        Task<Resource> Create(HttpContext httpContext, Resource resource, string correlationIdentifier);
+        Task<Resource> Delete(HttpContext httpContext, string identifier, string correlationIdentifier);
         Task<QueryResponseBase> Query(
-            HttpRequestMessage request,
+            HttpContext httpContext,
             IReadOnlyCollection<IFilter> filters,
             IReadOnlyCollection<string> requestedAttributePaths,
             IReadOnlyCollection<string> excludedAttributePaths,
             IPaginationParameters paginationParameters,
             string correlationIdentifier);
-        Task<Resource> Replace(HttpRequestMessage request, Resource resource, string correlationIdentifier);
+        Task<Resource> Replace(HttpContext httpContext, Resource resource, string correlationIdentifier);
         Task<Resource> Retrieve(
-            HttpRequestMessage request,
+            HttpContext httpContext,
             string identifier,
             IReadOnlyCollection<string> requestedAttributePaths,
             IReadOnlyCollection<string> excludedAttributePaths,
             string correlationIdentifier);
-        Task Update(
-            HttpRequestMessage request,
+        Task<Resource> Update(
+            HttpContext httpContext,
             string identifier,
             PatchRequestBase patchRequest,
             string correlationIdentifier);
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/IRequest.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/IRequest.cs
index ed39e3a0..5872d7f8 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/IRequest.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/IRequest.cs
@@ -4,14 +4,14 @@ namespace Microsoft.SCIM
 {
     using System;
     using System.Collections.Generic;
-    using System.Net.Http;
+    using Microsoft.AspNetCore.Http;
 
     public interface IRequest
     {
         Uri BaseResourceIdentifier { get; }
         string CorrelationIdentifier { get; }
         IReadOnlyCollection<IExtension> Extensions { get; }
-        HttpRequestMessage Request { get; }
+        HttpContext HttpContext { get; }
     }
 
     public interface IRequest<TPayload> : IRequest where TPayload : class
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/ISampleProvider.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/ISampleProvider.cs
deleted file mode 100644
index b81c6ed0..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/ISampleProvider.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    public interface ISampleProvider
-    {
-        Core2Group SampleGroup { get; }
-        PatchRequest2 SamplePatch { get; }
-        Core2EnterpriseUser SampleResource { get; }
-        Core2EnterpriseUser SampleUser { get; }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/InvalidBulkOperationContext.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/InvalidBulkOperationContext.cs
deleted file mode 100644
index 0384603b..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/InvalidBulkOperationContext.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Net.Http;
-
-    internal class InvalidBulkOperationContext : IBulkOperationContext
-    {
-        private readonly IBulkOperationState state;
-
-        public InvalidBulkOperationContext(
-            IRequest<BulkRequest2> request,
-            BulkRequestOperation operation)
-        {
-            if (null == request)
-            {
-                throw new ArgumentNullException(nameof(request));
-            }
-
-            if (null == operation)
-            {
-                throw new ArgumentNullException(nameof(operation));
-            }
-
-            this.state = new InvalidBulkOperationState(request, operation);
-        }
-
-        public bool Completed => true;
-
-        public bool Faulted => true;
-        
-        public IRequest<BulkRequest2> BulkRequest => this.state.BulkRequest;
-
-        public HttpMethod Method => this.state.Operation.Method;
-        
-        public BulkRequestOperation Operation => this.state.Operation;
-        
-        public BulkResponseOperation Response => this.state.Response;
-
-        public void Complete(BulkResponseOperation response) => this.state.Complete(response);
-
-        public bool TryPrepare() => this.state.TryPrepare();
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/InvalidBulkOperationState.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/InvalidBulkOperationState.cs
deleted file mode 100644
index 34f6909c..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/InvalidBulkOperationState.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-//------------------------------------------------------------
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-//------------------------------------------------------------
-
-namespace Microsoft.SCIM
-{
-    using System;
-
-    internal class InvalidBulkOperationState : IBulkOperationState
-    {
-        public InvalidBulkOperationState(
-            IRequest<BulkRequest2> request,
-            BulkRequestOperation operation)
-        {
-            this.BulkRequest = request ?? throw new ArgumentNullException(nameof(request));
-            this.Operation = operation ?? throw new ArgumentNullException(nameof(operation));
-        }
-
-        public IRequest<BulkRequest2> BulkRequest
-        {
-            get;
-            private set;
-        }
-
-        public BulkRequestOperation Operation
-        {
-            get;
-            private set;
-        }
-
-        public BulkResponseOperation Response
-        {
-            get;
-            private set;
-        }
-
-        public void Complete(BulkResponseOperation response)
-        {
-            if (null == response)
-            {
-                throw new ArgumentNullException(nameof(response));
-            }
-
-            if (response.Response is ErrorResponse)
-            {
-                this.Response = response;
-            }
-            else
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidResponse);
-            }
-        }
-
-        public bool TryPrepare() => false;
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Monitor/CriticalExceptionNotificationFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Monitor/CriticalExceptionNotificationFactory.cs
deleted file mode 100644
index cda91bbd..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Monitor/CriticalExceptionNotificationFactory.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System;
-
-    public sealed class CriticalExceptionNotificationFactory : NotificationFactory<Exception, IExceptionNotification>
-    {
-        private static readonly Lazy<NotificationFactory<Exception, IExceptionNotification>> Singleton =
-            new Lazy<NotificationFactory<Exception, IExceptionNotification>>(
-                () =>
-                    new CriticalExceptionNotificationFactory());
-
-        private CriticalExceptionNotificationFactory()
-        {
-        }
-
-        public static NotificationFactory<Exception, IExceptionNotification> Instance
-        {
-            get
-            {
-                return CriticalExceptionNotificationFactory.Singleton.Value;
-            }
-        }
-
-        public override IExceptionNotification CreateNotification(
-            Exception payload,
-            string correlationIdentifier,
-            long? identifier)
-        {
-            if (null == payload)
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            IExceptionNotification result;
-            if (string.IsNullOrWhiteSpace(correlationIdentifier))
-            {
-                if (!identifier.HasValue)
-                {
-                    result = new ExceptionNotification(payload, true);
-                }
-                else
-                {
-                    result = new ExceptionNotification(payload, true, identifier.Value);
-                }
-            }
-            else
-            {
-                if (!identifier.HasValue)
-                {
-                    result = new ExceptionNotification(payload, true, correlationIdentifier);
-                }
-                else
-                {
-                    result = new ExceptionNotification(payload, true, correlationIdentifier, identifier.Value);
-                }
-            }
-            return result;
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Monitor/InformationNotificationFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Monitor/InformationNotificationFactory.cs
deleted file mode 100644
index 6013a5a7..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Monitor/InformationNotificationFactory.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System;
-
-    public sealed class InformationNotificationFactory : NotificationFactoryBase<IInformationNotification>
-    {
-        private static readonly Lazy<NotificationFactoryBase<IInformationNotification>> Singleton =
-            new Lazy<NotificationFactoryBase<IInformationNotification>>(
-                () =>
-                    new InformationNotificationFactory());
-
-        private InformationNotificationFactory()
-        {
-        }
-
-        public static NotificationFactoryBase<IInformationNotification> Instance
-        {
-            get
-            {
-                return InformationNotificationFactory.Singleton.Value;
-            }
-        }
-
-        public override IInformationNotification CreateNotification(
-            string payload,
-            string correlationIdentifier,
-            long? identifier)
-        {
-            if (string.IsNullOrWhiteSpace(payload))
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            IInformationNotification result;
-            if (string.IsNullOrWhiteSpace(correlationIdentifier))
-            {
-                if (!identifier.HasValue)
-                {
-                    result = new InformationNotification(payload);
-                }
-                else
-                {
-                    result = new InformationNotification(payload, identifier.Value);
-                }
-            }
-            else
-            {
-                if (!identifier.HasValue)
-                {
-                    result = new InformationNotification(payload, correlationIdentifier);
-                }
-                else
-                {
-                    result = new InformationNotification(payload, correlationIdentifier, identifier.Value);
-                }
-            }
-            return result;
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Monitor/VerboseInformationNotificationFactory.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/Monitor/VerboseInformationNotificationFactory.cs
deleted file mode 100644
index 681f3680..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/Monitor/VerboseInformationNotificationFactory.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System;
-
-    public sealed class VerboseInformationNotificationFactory : NotificationFactoryBase<IInformationNotification>
-    {
-        private static readonly Lazy<NotificationFactoryBase<IInformationNotification>> Singleton =
-            new Lazy<NotificationFactoryBase<IInformationNotification>>(
-                () =>
-                    new VerboseInformationNotificationFactory());
-
-        private VerboseInformationNotificationFactory()
-        {
-        }
-
-        public static NotificationFactoryBase<IInformationNotification> Instance
-        {
-            get
-            {
-                return VerboseInformationNotificationFactory.Singleton.Value;
-            }
-        }
-
-        public override IInformationNotification CreateNotification(
-            string payload,
-            string correlationIdentifier,
-            long? identifier)
-        {
-            if (string.IsNullOrWhiteSpace(payload))
-            {
-                throw new ArgumentNullException(nameof(payload));
-            }
-
-            IInformationNotification result;
-            if (string.IsNullOrWhiteSpace(correlationIdentifier))
-            {
-                if (!identifier.HasValue)
-                {
-                    result = new InformationNotification(payload, true);
-                }
-                else
-                {
-                    result = new InformationNotification(payload, true, identifier.Value);
-                }
-            }
-            else
-            {
-                if (!identifier.HasValue)
-                {
-                    result = new InformationNotification(payload, true, correlationIdentifier);
-                }
-                else
-                {
-                    result = new InformationNotification(payload, true, correlationIdentifier, identifier.Value);
-                }
-            }
-            return result;
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/MonitoringMiddleware.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/MonitoringMiddleware.cs
deleted file mode 100644
index f2c7e079..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/MonitoringMiddleware.cs
+++ /dev/null
@@ -1,145 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-//namespace Microsoft.SCIM
-//{
-//    using System;
-//    using System.Collections.Generic;
-//    using System.Globalization;
-//    using System.Linq;
-//    using System.Text;
-//    using System.Threading.Tasks;
-//    using Microsoft.Owin;
-
-//    public sealed class MonitoringMiddleware : OwinMiddleware
-//    {
-//        public MonitoringMiddleware(OwinMiddleware next, IMonitor monitor)
-//            : base(next)
-//        {
-//            this.Monitor = monitor ?? throw new ArgumentNullException(nameof(monitor));
-//        }
-
-//        private IMonitor Monitor
-//        {
-//            get;
-//            set;
-//        }
-
-//        private static string ComposeRequest(IOwinContext context)
-//        {
-//            if (null == context)
-//            {
-//                throw new ArgumentNullException(nameof(context));
-//            }
-
-//            string method = null;
-//            Uri resource = null;
-//            string headers = null;
-
-//            if (context.Request != null)
-//            {
-//                method = context.Request.Method;
-//                resource = context.Request.Uri;
-
-//                if (context.Request.Headers != null)
-//                {
-//                    headers =
-//                        context
-//                        .Request
-//                        .Headers
-//                        .ToDictionary(
-//                            (KeyValuePair<string, string[]> item) =>
-//                                item.Key,
-//                            (KeyValuePair<string, string[]> item) =>
-//                                string.Join(
-//                                        SystemForCrossDomainIdentityManagementServiceResources.SeparatorHeaderValues,
-//                                        item.Value))
-//                        .Select(
-//                            (KeyValuePair<string, string> item) =>
-//                                string.Format(
-//                                    CultureInfo.InvariantCulture,
-//                                    SystemForCrossDomainIdentityManagementServiceResources.HeaderTemplate,
-//                                    item.Key,
-//                                    item.Value))
-//                        .Aggregate(
-//                            new StringBuilder(),
-//                            (StringBuilder aggregate, string item) =>
-//                                aggregate.AppendLine(item))
-//                        .ToString();
-//                }
-//            }
-
-//            string result =
-//                string.Format(
-//                    CultureInfo.InvariantCulture,
-//                    SystemForCrossDomainIdentityManagementServiceResources.MessageTemplate,
-//                    method,
-//                    resource,
-//                    headers);
-
-//            return result;
-//        }
-
-//        public override async Task Invoke(IOwinContext context)
-//        {
-//            if (null == context)
-//            {
-//                throw new ArgumentNullException(nameof(context));
-//            }
-
-//            if (null == context.Request)
-//            {
-//                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidContext);
-//            }
-
-//            string requestIdentifier = context.Request.Identify();
-
-//            string message = MonitoringMiddleware.ComposeRequest(context);
-
-//            IInformationNotification receptionNotification =
-//                InformationNotificationFactory.Instance.FormatNotification(
-//                    SystemForCrossDomainIdentityManagementServiceResources.InformationRequestReceivedTemplate,
-//                    requestIdentifier,
-//                    ServiceNotificationIdentifiers.MonitoringMiddlewareReception,
-//                    message);
-//            this.Monitor.Inform(receptionNotification);
-
-//            try
-//            {
-//                if (this.Next != null)
-//                {
-//                    await this.Next.Invoke(context).ConfigureAwait(false);
-//                }
-//            }
-//            catch (Exception exception)
-//            {
-//                IExceptionNotification exceptionNotification =
-//                    ExceptionNotificationFactory.Instance.CreateNotification(
-//                        exception,
-//                        requestIdentifier,
-//                        ServiceNotificationIdentifiers.MonitoringMiddlewareInvocationException);
-//                this.Monitor.Report(exceptionNotification);
-
-//                throw;
-//            }
-
-//            string responseStatusCode;
-//            if (context.Response != null)
-//            {
-//                responseStatusCode = context.Response.StatusCode.ToString(CultureInfo.InvariantCulture);
-//            }
-//            else
-//            {
-//                responseStatusCode = null;
-//            }
-
-//            IInformationNotification processedNotification =
-//                InformationNotificationFactory.Instance.FormatNotification(
-//                    SystemForCrossDomainIdentityManagementServiceResources.InformationRequestProcessedTemplate,
-//                    requestIdentifier,
-//                    ServiceNotificationIdentifiers.MonitoringMiddlewareRequestProcessed,
-//                    message,
-//                    responseStatusCode);
-//            this.Monitor.Inform(processedNotification);
-//        }
-//    }
-//}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/ProviderAdapterTemplate.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/ProviderAdapterTemplate.cs
index 2a70f2b3..542edd11 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/ProviderAdapterTemplate.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/ProviderAdapterTemplate.cs
@@ -4,8 +4,8 @@ namespace Microsoft.SCIM
 {
     using System;
     using System.Collections.Generic;
-    using System.Net.Http;
     using System.Threading.Tasks;
+    using Microsoft.AspNetCore.Http;
 
     public abstract class ProviderAdapterTemplate<T> : IProviderAdapter<T> where T : Resource
     {
@@ -22,11 +22,11 @@ public IProvider Provider
 
         public abstract string SchemaIdentifier { get; }
 
-        public virtual async Task<Resource> Create(HttpRequestMessage request, Resource resource, string correlationIdentifier)
+        public virtual async Task<Resource> Create(HttpContext httpContext, Resource resource, string correlationIdentifier)
         {
-            if (null == request)
+            if (null == httpContext)
             {
-                throw new ArgumentNullException(nameof(request));
+                throw new ArgumentNullException(nameof(httpContext));
             }
 
             if (null == resource)
@@ -40,7 +40,7 @@ public virtual async Task<Resource> Create(HttpRequestMessage request, Resource
             }
 
             IReadOnlyCollection<IExtension> extensions = this.ReadExtensions();
-            IRequest<Resource> creationRequest = new CreationRequest(request, resource, correlationIdentifier, extensions);
+            IRequest<Resource> creationRequest = new SystemForCrossDomainIdentityManagementRequest<Resource>(httpContext, resource, correlationIdentifier, extensions);
             Resource result = await this.Provider.CreateAsync(creationRequest).ConfigureAwait(false);
             return result;
         }
@@ -61,11 +61,11 @@ public virtual IResourceIdentifier CreateResourceIdentifier(string identifier)
             return result;
         }
 
-        public virtual async Task Delete(HttpRequestMessage request, string identifier, string correlationIdentifier)
+        public virtual async Task<Resource> Delete(HttpContext httpContext, string identifier, string correlationIdentifier)
         {
-            if (null == request)
+            if (null == httpContext)
             {
-                throw new ArgumentNullException(nameof(request));
+                throw new ArgumentNullException(nameof(httpContext));
             }
 
             if (string.IsNullOrWhiteSpace(identifier))
@@ -81,11 +81,11 @@ public virtual async Task Delete(HttpRequestMessage request, string identifier,
             IReadOnlyCollection<IExtension> extensions = this.ReadExtensions();
             IResourceIdentifier resourceIdentifier = this.CreateResourceIdentifier(identifier);
             IRequest<IResourceIdentifier> deletionRequest =
-                new DeletionRequest(request, resourceIdentifier, correlationIdentifier, extensions);
-            await this.Provider.DeleteAsync(deletionRequest).ConfigureAwait(false);
+                new SystemForCrossDomainIdentityManagementRequest<IResourceIdentifier>(httpContext, resourceIdentifier, correlationIdentifier, extensions);
+            return await this.Provider.DeleteAsync(deletionRequest).ConfigureAwait(false);
         }
 
-        public virtual string GetPath(HttpRequestMessage request)
+        public virtual string GetPath()
         {
             IReadOnlyCollection<IExtension> extensions = this.ReadExtensions();
             if (extensions != null && extensions.TryGetPath(this.SchemaIdentifier, out string result))
@@ -98,16 +98,16 @@ public virtual string GetPath(HttpRequestMessage request)
         }
 
         public virtual async Task<QueryResponseBase> Query(
-            HttpRequestMessage request,
+            HttpContext httpContext,
             IReadOnlyCollection<IFilter> filters,
             IReadOnlyCollection<string> requestedAttributePaths,
             IReadOnlyCollection<string> excludedAttributePaths,
             IPaginationParameters paginationParameters,
             string correlationIdentifier)
         {
-            if (null == request)
+            if (null == httpContext)
             {
-                throw new ArgumentNullException(nameof(request));
+                throw new ArgumentNullException(nameof(httpContext));
             }
 
             if (null == requestedAttributePaths)
@@ -125,13 +125,13 @@ public virtual async Task<QueryResponseBase> Query(
                 throw new ArgumentNullException(nameof(correlationIdentifier));
             }
 
-            string path = this.GetPath(request);
+            string path = this.GetPath();
             IQueryParameters queryParameters =
                 new QueryParameters(this.SchemaIdentifier, path, filters, requestedAttributePaths, excludedAttributePaths);
             queryParameters.PaginationParameters = paginationParameters;
             IReadOnlyCollection<IExtension> extensions = this.ReadExtensions();
             IRequest<IQueryParameters> queryRequest =
-                new QueryRequest(request, queryParameters, correlationIdentifier, extensions);
+                new SystemForCrossDomainIdentityManagementRequest<IQueryParameters>(httpContext, queryParameters, correlationIdentifier, extensions);
             QueryResponseBase result = await this.Provider.PaginateQueryAsync(queryRequest).ConfigureAwait(false);
 
             return result;
@@ -152,13 +152,13 @@ private IReadOnlyCollection<IExtension> ReadExtensions()
         }
 
         public virtual async Task<Resource> Replace(
-            HttpRequestMessage request,
+            HttpContext httpContext,
             Resource resource,
             string correlationIdentifier)
         {
-            if (null == request)
+            if (null == httpContext)
             {
-                throw new ArgumentNullException(nameof(request));
+                throw new ArgumentNullException(nameof(httpContext));
             }
 
             if (null == resource)
@@ -172,21 +172,21 @@ public virtual async Task<Resource> Replace(
             }
 
             IReadOnlyCollection<IExtension> extensions = this.ReadExtensions();
-            IRequest<Resource> replaceRequest = new ReplaceRequest(request, resource, correlationIdentifier, extensions);
+            IRequest<Resource> replaceRequest = new SystemForCrossDomainIdentityManagementRequest<Resource>(httpContext, resource, correlationIdentifier, extensions);
             Resource result = await this.Provider.ReplaceAsync(replaceRequest).ConfigureAwait(false);
             return result;
         }
 
         public virtual async Task<Resource> Retrieve(
-            HttpRequestMessage request,
+            HttpContext httpContext,
             string identifier,
             IReadOnlyCollection<string> requestedAttributePaths,
             IReadOnlyCollection<string> excludedAttributePaths,
             string correlationIdentifier)
         {
-            if (null == request)
+            if (null == httpContext)
             {
-                throw new ArgumentNullException(nameof(request));
+                throw new ArgumentNullException(nameof(httpContext));
             }
 
             if (string.IsNullOrWhiteSpace(identifier))
@@ -204,7 +204,7 @@ public virtual async Task<Resource> Retrieve(
                 throw new ArgumentNullException(nameof(correlationIdentifier));
             }
 
-            string path = this.GetPath(request);
+            string path = this.GetPath();
             IResourceRetrievalParameters retrievalParameters =
                 new ResourceRetrievalParameters(
                         this.SchemaIdentifier,
@@ -214,20 +214,19 @@ public virtual async Task<Resource> Retrieve(
                         excludedAttributePaths);
             IReadOnlyCollection<IExtension> extensions = this.ReadExtensions();
             IRequest<IResourceRetrievalParameters> retrievalRequest =
-                new RetrievalRequest(request, retrievalParameters, correlationIdentifier, extensions);
+                new SystemForCrossDomainIdentityManagementRequest<IResourceRetrievalParameters>(httpContext, retrievalParameters, correlationIdentifier, extensions);
             Resource result = await this.Provider.RetrieveAsync(retrievalRequest).ConfigureAwait(false);
             return result;
         }
 
-        public virtual async Task Update(
-            HttpRequestMessage request,
+        public virtual async Task<Resource> Update(HttpContext httpContext,
             string identifier,
             PatchRequestBase patchRequest,
             string correlationIdentifier)
         {
-            if (null == request)
+            if (null == httpContext)
             {
-                throw new ArgumentNullException(nameof(request));
+                throw new ArgumentNullException(nameof(httpContext));
             }
 
             if (string.IsNullOrWhiteSpace(correlationIdentifier))
@@ -243,8 +242,8 @@ public virtual async Task Update(
                     PatchRequest = patchRequest
                 };
             IReadOnlyCollection<IExtension> extensions = this.ReadExtensions();
-            IRequest<IPatch> updateRequest = new UpdateRequest(request, patch, correlationIdentifier, extensions);
-            await this.Provider.UpdateAsync(updateRequest).ConfigureAwait(false);
+            IRequest<IPatch> updateRequest = new SystemForCrossDomainIdentityManagementRequest<IPatch>(httpContext, patch, correlationIdentifier, extensions);
+            return await this.Provider.UpdateAsync(updateRequest).ConfigureAwait(false);
         }
     }
 }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/ProviderBase.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/ProviderBase.cs
index 202f2367..e4fc620a 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/ProviderBase.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/ProviderBase.cs
@@ -131,9 +131,10 @@ public virtual async Task<Resource> CreateAsync(IRequest<Resource> request)
             return result;
         }
 
-        public abstract Task DeleteAsync(IResourceIdentifier resourceIdentifier, string correlationIdentifier);
+        public abstract Task<Resource> DeleteAsync(IResourceIdentifier resourceIdentifier,
+            string correlationIdentifier);
 
-        public virtual async Task DeleteAsync(IRequest<IResourceIdentifier> request)
+        public virtual async Task<Resource> DeleteAsync(IRequest<IResourceIdentifier> request)
         {
             if (null == request)
             {
@@ -150,7 +151,7 @@ public virtual async Task DeleteAsync(IRequest<IResourceIdentifier> request)
                 throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
             }
 
-            await this.DeleteAsync(request.Payload, request.CorrelationIdentifier).ConfigureAwait(false);
+            return await this.DeleteAsync(request.Payload, request.CorrelationIdentifier).ConfigureAwait(false);
         }
 
         public virtual async Task<QueryResponseBase> PaginateQueryAsync(IRequest<IQueryParameters> request)
@@ -177,7 +178,7 @@ public  virtual async Task<BulkResponse2> ProcessAsync(IRequest<BulkRequest2> re
                 throw new ArgumentNullException(nameof(request));
             }
 
-            if (null == request.Request)
+            if (null == request.HttpContext)
             {
                 throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
             }
@@ -338,8 +339,7 @@ public virtual async Task<Resource[]> QueryAsync(IRequest<IQueryParameters> requ
                 throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
             }
 
-            Resource[] result = await this.QueryAsync(request.Payload, request.CorrelationIdentifier).ConfigureAwait(false);
-            return result;
+            return await this.QueryAsync(request.Payload, request.CorrelationIdentifier).ConfigureAwait(false);
         }
 
         public virtual Task<Resource> ReplaceAsync(Resource resource, string correlationIdentifier)
@@ -364,8 +364,7 @@ public virtual async Task<Resource> ReplaceAsync(IRequest<Resource> request)
                 throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
             }
 
-            Resource result = await this.ReplaceAsync(request.Payload, request.CorrelationIdentifier).ConfigureAwait(false);
-            return result;
+            return await this.ReplaceAsync(request.Payload, request.CorrelationIdentifier).ConfigureAwait(false);
         }
 
         public abstract Task<Resource> RetrieveAsync(IResourceRetrievalParameters parameters, string correlationIdentifier);
@@ -387,13 +386,12 @@ public virtual async Task<Resource> RetrieveAsync(IRequest<IResourceRetrievalPar
                 throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
             }
 
-            Resource result = await this.RetrieveAsync(request.Payload, request.CorrelationIdentifier).ConfigureAwait(false);
-            return result;
+            return await this.RetrieveAsync(request.Payload, request.CorrelationIdentifier).ConfigureAwait(false);
         }
 
-        public abstract Task UpdateAsync(IPatch patch, string correlationIdentifier);
+        public abstract Task<Resource> UpdateAsync(IPatch patch, string correlationIdentifier);
 
-        public virtual async Task UpdateAsync(IRequest<IPatch> request)
+        public virtual async Task<Resource> UpdateAsync(IRequest<IPatch> request)
         {
             if (null == request)
             {
@@ -410,7 +408,7 @@ public virtual async Task UpdateAsync(IRequest<IPatch> request)
                 throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
             }
 
-            await this.UpdateAsync(request.Payload, request.CorrelationIdentifier).ConfigureAwait(false);
+            return await this.UpdateAsync(request.Payload, request.CorrelationIdentifier).ConfigureAwait(false);
         }
     }
 }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/QueryRequest.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/QueryRequest.cs
deleted file mode 100644
index 4917ca8b..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/QueryRequest.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-    using System.Net.Http;
-
-    public sealed class QueryRequest :
-        SystemForCrossDomainIdentityManagementRequest<IQueryParameters>
-    {
-        public QueryRequest(
-            HttpRequestMessage request,
-            IQueryParameters payload,
-            string correlationIdentifier,
-            IReadOnlyCollection<IExtension> extensions)
-            : base(request, payload, correlationIdentifier, extensions)
-        {
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/ReplaceRequest.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/ReplaceRequest.cs
deleted file mode 100644
index 6defd66a..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/ReplaceRequest.cs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-    using System.Net.Http;
-
-    public sealed class ReplaceRequest : SystemForCrossDomainIdentityManagementRequest<Resource>
-    {
-        public ReplaceRequest(
-            HttpRequestMessage request,
-            Resource payload,
-            string correlationIdentifier,
-            IReadOnlyCollection<IExtension> extensions)
-            : base(request, payload, correlationIdentifier, extensions)
-        {
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/RequestExtensions.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/RequestExtensions.cs
index 4d1d661a..c6d3daf5 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/RequestExtensions.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/RequestExtensions.cs
@@ -6,9 +6,10 @@ namespace Microsoft.SCIM
     using System.Linq;
     using System.Net;
     using System.Net.Http;
-    using System.Web.Http;
     using System.Collections.Generic;
     using Newtonsoft.Json;
+    using Microsoft.AspNetCore.Http;
+    using Microsoft.Extensions.Primitives;
 
     public static class RequestExtensions
     {
@@ -24,24 +25,24 @@ public static class RequestExtensions
                     SegmentSeparator.ToArray());
 
         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods", MessageId = "0", Justification = "False analysis of the 'this' parameter of an extension method")]
-        public static Uri GetBaseResourceIdentifier(this HttpRequestMessage request)
+        public static Uri GetBaseResourceIdentifier(this HttpContext context)
         {
-            if (null == request.RequestUri)
+            if (null == context.Request.Path.Value)
             {
                 throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
             }
 
             string lastSegment =
-                request.RequestUri.AbsolutePath.Split(
+                context.Request.Path.Value.Split(
                     RequestExtensions.SegmentSeparators.Value,
                     StringSplitOptions.RemoveEmptyEntries)
                 .Last();
             if (string.Equals(lastSegment, SchemaConstants.PathInterface, StringComparison.OrdinalIgnoreCase))
             {
-                return request.RequestUri;
+                return new Uri($"{context.Request.Scheme}://{context.Request.Host.Value}{context.Request.Path.Value}");
             }
 
-            string resourceIdentifier = request.RequestUri.AbsoluteUri;
+            string resourceIdentifier = $"{context.Request.Scheme}://{context.Request.Host.Value}{context.Request.Path.Value}";
 
             int indexInterface =
                 resourceIdentifier
@@ -59,9 +60,10 @@ public static Uri GetBaseResourceIdentifier(this HttpRequestMessage request)
             return result;
         }
 
-        public static bool TryGetRequestIdentifier(this HttpRequestMessage request, out string requestIdentifier)
+        public static bool TryGetRequestIdentifier(this HttpContext context, out string requestIdentifier)
         {
-            request?.Headers.TryGetValues("client-id", out IEnumerable<string> _);
+            // TODO: Who knows why?
+            context.Request.Headers.TryGetValue("client-id", out StringValues _);
             requestIdentifier = Guid.NewGuid().ToString();
             return true;
         }
@@ -114,11 +116,9 @@ private static void Relate(
             }
             catch
             {
-                throw new HttpResponseException(HttpStatusCode.BadRequest);
+                throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
             }
-                   
         }
-        
 
         private static void Enlist(
             this IRequest<BulkRequest2> request,
@@ -191,7 +191,7 @@ private static void Enlist(
             {
                 IBulkOperationContext context = new BulkDeletionOperationContext(request, operation);
                 operations.Add(context);
-                return; 
+                return;
             }
 
             if (ProtocolExtensions.PatchMethod == operation.Method)
@@ -203,7 +203,7 @@ private static void Enlist(
                 return;
             }
 
-            throw new HttpResponseException(HttpStatusCode.BadRequest);
+            throw new NotSupportedException();
         }
 
         public static Queue<IBulkOperationContext> EnqueueOperations(this IRequest<BulkRequest2> request)
@@ -271,7 +271,7 @@ private static void Relate(
                         }
                         break;
                     default:
-                        throw new HttpResponseException(HttpStatusCode.BadRequest);
+                        throw new CustomHttpResponseException(HttpStatusCode.BadRequest);
                 }
             }
         }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/ResourceQuery.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/ResourceQuery.cs
index b4608599..d76b09c9 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/ResourceQuery.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/ResourceQuery.cs
@@ -9,7 +9,7 @@ namespace Microsoft.SCIM
     using System.Linq;
     using System.Net;
     using System.Web;
-    using System.Web.Http;
+    using Microsoft.AspNetCore.Http;
 
     public sealed class ResourceQuery : IResourceQuery
     {
@@ -117,6 +117,79 @@ public ResourceQuery(Uri resource)
             }
         }
 
+        public ResourceQuery(HttpContext context)
+        {
+            if (null == context)
+            {
+                throw new ArgumentNullException(nameof(context));
+            }
+
+            IQueryCollection keyedValues = context.Request.Query;
+            IEnumerable<string> keys = keyedValues.Keys;
+            foreach (string key in keys)
+            {
+                if (string.Equals(key, QueryKeys.Attributes, StringComparison.OrdinalIgnoreCase))
+                {
+                    string attributeExpression = keyedValues[key];
+                    if (!string.IsNullOrWhiteSpace(attributeExpression))
+                    {
+                        this.Attributes = ResourceQuery.ParseAttributes(attributeExpression);
+                    }
+                }
+
+                if (string.Equals(key, QueryKeys.Count, StringComparison.OrdinalIgnoreCase))
+                {
+                    Action<IPaginationParameters, int> action =
+                        new Action<IPaginationParameters, int>(
+                            (IPaginationParameters pagination, int paginationValue) =>
+                                pagination.Count = paginationValue);
+                    this.ApplyPaginationParameter(keyedValues[key], action);
+                }
+
+                if (string.Equals(key, QueryKeys.ExcludedAttributes, StringComparison.OrdinalIgnoreCase))
+                {
+                    string attributeExpression = keyedValues[key];
+                    if (!string.IsNullOrWhiteSpace(attributeExpression))
+                    {
+                        this.ExcludedAttributes = ResourceQuery.ParseAttributes(attributeExpression);
+                    }
+                }
+
+                if (string.Equals(key, QueryKeys.Filter, StringComparison.OrdinalIgnoreCase))
+                {
+                    string filterExpression = keyedValues[key];
+                    if (!string.IsNullOrWhiteSpace(filterExpression))
+                    {
+                        this.Filters = ResourceQuery.ParseFilters(filterExpression);
+                    }
+                }
+
+                if (string.Equals(key, QueryKeys.StartIndex, StringComparison.OrdinalIgnoreCase))
+                {
+                    Action<IPaginationParameters, int> action =
+                        new Action<IPaginationParameters, int>(
+                            (IPaginationParameters pagination, int paginationValue) =>
+                                pagination.StartIndex = paginationValue);
+                    this.ApplyPaginationParameter(keyedValues[key], action);
+                }
+            }
+
+            if (null == this.Filters)
+            {
+                this.Filters = Array.Empty<Filter>();
+            }
+
+            if (null == this.Attributes)
+            {
+                this.Attributes = Array.Empty<string>();
+            }
+
+            if (null == this.ExcludedAttributes)
+            {
+                this.ExcludedAttributes = Array.Empty<string>();
+            }
+        }
+
         public IReadOnlyCollection<string> Attributes
         {
             get;
@@ -160,6 +233,7 @@ private void ApplyPaginationParameter(
             {
                 this.PaginationParameters = new PaginationParameters();
             }
+
             action(this.PaginationParameters, parsedValue);
         }
 
@@ -172,11 +246,11 @@ private static IReadOnlyCollection<string> ParseAttributes(string attributeExpre
 
             IReadOnlyCollection<string> results =
                 attributeExpression
-                .Split(ResourceQuery.SeperatorsAttributes.Value)
-                .Select(
-                    (string item) =>
-                        item.Trim())
-                .ToArray();
+                    .Split(ResourceQuery.SeperatorsAttributes.Value)
+                    .Select(
+                        (string item) =>
+                            item.Trim())
+                    .ToArray();
             return results;
         }
 
@@ -189,7 +263,7 @@ private static IReadOnlyCollection<IFilter> ParseFilters(string filterExpression
 
             if (!Filter.TryParse(filterExpression, out IReadOnlyCollection<IFilter> results))
             {
-                throw new HttpResponseException(HttpStatusCode.NotAcceptable);
+                throw new CustomHttpResponseException(HttpStatusCode.NotAcceptable);
             }
 
             return results;
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/RetrievalRequest.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/RetrievalRequest.cs
deleted file mode 100644
index 0cecdb0f..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/RetrievalRequest.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-    using System.Net.Http;
-
-    public sealed class RetrievalRequest :
-        SystemForCrossDomainIdentityManagementRequest<IResourceRetrievalParameters>
-    {
-        public RetrievalRequest(
-            HttpRequestMessage request,
-            IResourceRetrievalParameters payload,
-            string correlationIdentifier,
-            IReadOnlyCollection<IExtension> extensions)
-            : base(request, payload, correlationIdentifier, extensions)
-        {
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/RootProviderAdapter .cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/RootProviderAdapter .cs
index d7d6cde3..8e695ad5 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/RootProviderAdapter .cs	
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/RootProviderAdapter .cs	
@@ -1,12 +1,12 @@
 // Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
 
+
 namespace Microsoft.SCIM
 {
     using System.Collections.Generic;
-    using System.Net;
-    using System.Net.Http;
+    using System;
     using System.Threading.Tasks;
-    using System.Web.Http;
+    using Microsoft.AspNetCore.Http;
 
     internal class RootProviderAdapter : ProviderAdapterTemplate<Resource>
     {
@@ -24,51 +24,51 @@ public override string SchemaIdentifier
         }
 
         public override Task<Resource> Create(
-            HttpRequestMessage request,
+            HttpContext httpContext,
             Resource resource,
             string correlationIdentifier)
         {
-            throw new HttpResponseException(HttpStatusCode.NotImplemented);
+            throw new NotImplementedException();
         }
 
         public override IResourceIdentifier CreateResourceIdentifier(string identifier)
         {
-            throw new HttpResponseException(HttpStatusCode.NotImplemented);
+            throw new NotImplementedException();
         }
 
-        public override Task Delete(
-            HttpRequestMessage request,
+        public override Task<Resource> Delete(
+            HttpContext httpContext,
             string identifier,
             string correlationIdentifier)
         {
-            throw new HttpResponseException(HttpStatusCode.NotImplemented);
+            throw new NotImplementedException();
         }
 
         public override Task<Resource> Replace(
-            HttpRequestMessage request,
+            HttpContext httpContext,
             Resource resource, string
             correlationIdentifier)
         {
-            throw new HttpResponseException(HttpStatusCode.NotImplemented);
+            throw new NotImplementedException();
         }
 
         public override Task<Resource> Retrieve(
-            HttpRequestMessage request,
+            HttpContext httpContext,
             string identifier,
             IReadOnlyCollection<string> requestedAttributePaths,
             IReadOnlyCollection<string> excludedAttributePaths,
             string correlationIdentifier)
         {
-            throw new HttpResponseException(HttpStatusCode.NotImplemented);
+            throw new NotImplementedException();
         }
 
-        public override Task Update(
-            HttpRequestMessage request,
+        public override Task<Resource> Update(
+            HttpContext httpContext,
             string identifier,
             PatchRequestBase patchRequest,
             string correlationIdentifier)
         {
-            throw new HttpResponseException(HttpStatusCode.NotImplemented);
+            throw new NotImplementedException();
         }
     }
 }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/SampleProvider.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/SampleProvider.cs
deleted file mode 100644
index 7a24f06b..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/SampleProvider.cs
+++ /dev/null
@@ -1,635 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.Globalization;
-    using System.Linq;
-    using System.Net;
-    using System.Threading.Tasks;
-    using System.Web.Http;
-    using Newtonsoft.Json;
-
-    public sealed class SampleProvider : ProviderBase, ISampleProvider
-    {
-        public const string ElectronicMailAddressHome = "babs@jensen.org";
-        public const string ElectronicMailAddressWork = "bjensen@example.com";
-
-        public const string ExtensionAttributeEnterpriseUserCostCenter = "4130";
-        public const string ExtensionAttributeEnterpriseUserDepartment = "Tour Operations";
-        public const string ExtensionAttributeEnterpriseUserDivision = "Theme Park";
-        public const string ExtensionAttributeEnterpriseUserEmployeeNumber = "701984";
-        public const string ExtensionAttributeEnterpriseUserOrganization = "Universal Studios";
-
-        public const string GroupName = "Creative & Skinning";
-        public const string IdentifierGroup = "acbf3ae7-8463-4692-b4fd-9b4da3f908ce";
-        public const string IdentifierRole = "DA3B77DF-F495-45C7-9AAC-EC083B99A9D3";
-        public const string IdentifierUser = "2819c223-7f76-453a-919d-413861904646";
-        public const string IdentifierExternal = "bjensen";
-
-        public const int LimitPageSize = 6;
-
-        public const string Locale = "en-Us";
-        public const string ManagerDisplayName = "John Smith";
-        public const string ManagerIdentifier = "26118915-6090-4610-87e4-49d8ca9f808d";
-        private const string NameFamily = "Jensen";
-        private const string NameFormatted = "Ms. Barbara J Jensen III";
-        private const string NameGiven = "Barbara";
-        private const string NameHonorificPrefix = "Ms.";
-        private const string NameHonorificSuffix = "III";
-        private const string NameUser = "bjensen";
-        public const string PhotoValue = "https://photos.example.com/profilephoto/72930000000Ccne/F";
-        public const string ProfileUrl = "https://login.example.com/bjensen";
-        public const string RoleDescription = "Attends an educational institution";
-        public const string RoleDisplay = "Student";
-        public const string RoleValue = "student";
-        public const string TimeZone = "America/Los_Angeles";
-        public const string UserType = "Employee";
-
-        private readonly ElectronicMailAddress sampleElectronicMailAddressHome;
-        private readonly ElectronicMailAddress sampleElectronicMailAddressWork;
-
-        private readonly IReadOnlyCollection<ElectronicMailAddress> sampleElectronicMailAddresses;
-        private readonly Manager sampleManager;
-        private readonly Name sampleName;
-        private readonly OperationValue sampleOperationValue;
-        private readonly PatchOperation2Combined sampleOperation;
-        private readonly PatchRequest2 samplePatch;
-
-        private readonly Core2Group sampleGroup;
-        private readonly Core2EnterpriseUser sampleUser;
-
-        public SampleProvider()
-        {
-            this.sampleElectronicMailAddressHome =
-                new ElectronicMailAddress
-                {
-                    ItemType = ElectronicMailAddress.Home,
-                    Value = SampleProvider.ElectronicMailAddressHome
-                };
-
-            this.sampleElectronicMailAddressWork =
-                new ElectronicMailAddress
-                {
-                    ItemType = ElectronicMailAddressWork,
-                    Primary = true,
-                    Value = SampleProvider.ElectronicMailAddressWork
-                };
-
-            this.sampleElectronicMailAddresses =
-                new ElectronicMailAddress[]
-                    {
-                        this.sampleElectronicMailAddressHome,
-                        this.sampleElectronicMailAddressWork
-                    };
-
-            this.sampleManager =
-                new Manager()
-                {
-                    Value = SampleProvider.ManagerIdentifier,
-                };
-
-            this.sampleName =
-                new Name()
-                {
-                    FamilyName = SampleProvider.NameFamily,
-                    Formatted = SampleProvider.NameFormatted,
-                    GivenName = SampleProvider.NameGiven,
-                    HonorificPrefix = SampleProvider.NameHonorificPrefix,
-                    HonorificSuffix = SampleProvider.NameHonorificSuffix
-                };
-
-            this.sampleOperationValue =
-                new OperationValue()
-                {
-                    Value = SampleProvider.IdentifierUser
-                };
-
-            this.sampleOperation = this.ConstructOperation();
-
-            this.samplePatch = this.ConstructPatch();
-
-            this.sampleUser =
-                new Core2EnterpriseUser()
-                {
-                    Active = true,
-                    ElectronicMailAddresses = this.sampleElectronicMailAddresses,
-                    ExternalIdentifier = SampleProvider.IdentifierExternal,
-                    Identifier = SampleProvider.IdentifierUser,
-                    Name = this.sampleName,
-                    UserName = SampleProvider.NameUser
-                };
-
-            ExtensionAttributeEnterpriseUser2 enterpriseExtensionAttributeEnterpriseUser2 =
-                new ExtensionAttributeEnterpriseUser2()
-                {
-                    CostCenter = SampleProvider.ExtensionAttributeEnterpriseUserCostCenter,
-                    Department = SampleProvider.ExtensionAttributeEnterpriseUserDepartment,
-                    Division = SampleProvider.ExtensionAttributeEnterpriseUserDivision,
-                    EmployeeNumber = SampleProvider.ExtensionAttributeEnterpriseUserEmployeeNumber,
-                    Manager = this.sampleManager,
-                    Organization = SampleProvider.ExtensionAttributeEnterpriseUserOrganization
-                };
-
-            this.SampleUser.EnterpriseExtension = enterpriseExtensionAttributeEnterpriseUser2;
-
-            this.sampleGroup =
-                new Core2Group()
-                {
-                    DisplayName = SampleProvider.GroupName,
-                };
-        }
-
-        public Core2Group SampleGroup
-        {
-            get
-            {
-                return this.sampleGroup;
-            }
-        }
-
-        public PatchRequest2 SamplePatch
-        {
-            get
-            {
-                return this.samplePatch;
-            }
-        }
-
-        public Core2EnterpriseUser SampleResource
-        {
-            get
-            {
-                return this.SampleUser;
-            }
-        }
-
-        public Core2EnterpriseUser SampleUser
-        {
-            get
-            {
-                return this.sampleUser;
-            }
-        }
-
-        public override Task<Resource> CreateAsync(Resource resource, string correlationIdentifier)
-        {
-            if (null == resource)
-            {
-                throw new ArgumentNullException(nameof(resource));
-            }
-
-            resource.Identifier = SampleProvider.IdentifierUser;
-
-            Task<Resource> result = Task.FromResult(resource);
-            return result;
-        }
-
-        private PatchOperation2Combined ConstructOperation()
-        {
-            IPath path = Path.Create(AttributeNames.Members);
-            PatchOperation2Combined result =
-                new PatchOperation2Combined()
-                {
-                    Name = OperationName.Add,
-                    Path = path
-                };
-            result.Value = JsonConvert.SerializeObject(this.sampleOperationValue);
-            return result;
-        }
-
-        private PatchRequest2 ConstructPatch()
-        {
-            PatchRequest2 result = new PatchRequest2();
-            result.AddOperation(this.sampleOperation);
-            return result;
-        }
-
-        public override Task DeleteAsync(IResourceIdentifier resourceIdentifier, string correlationIdentifier)
-        {
-            if (null == resourceIdentifier)
-            {
-                throw new ArgumentNullException(nameof(resourceIdentifier));
-            }
-
-            Task result = Task.WhenAll();
-            return result;
-        }
-
-        private static bool HasMember(IResourceIdentifier containerIdentifier, string memberAttributePath, string memberIdentifier)
-        {
-            if (null == containerIdentifier)
-            {
-                throw new ArgumentNullException(nameof(containerIdentifier));
-            }
-
-            if (string.IsNullOrWhiteSpace(memberAttributePath))
-            {
-                throw new ArgumentNullException(nameof(memberAttributePath));
-            }
-
-            if (string.IsNullOrWhiteSpace(memberIdentifier))
-            {
-                throw new ArgumentNullException(nameof(memberIdentifier));
-            }
-
-            if (string.IsNullOrWhiteSpace(containerIdentifier.Identifier))
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidIdentifier);
-            }
-
-            if (!string.Equals(memberAttributePath, AttributeNames.Members, StringComparison.Ordinal))
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterAttributePathNotSupportedTemplate,
-                        memberAttributePath);
-                throw new NotSupportedException(exceptionMessage);
-            }
-
-            if (!string.Equals(SchemaIdentifiers.Core2Group, containerIdentifier.SchemaIdentifier, StringComparison.Ordinal))
-            {
-                throw new NotSupportedException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterNotSupported);
-            }
-
-            bool result =
-                    string.Equals(SampleProvider.IdentifierGroup, containerIdentifier.Identifier, StringComparison.OrdinalIgnoreCase)
-                && string.Equals(SampleProvider.IdentifierUser, memberIdentifier, StringComparison.OrdinalIgnoreCase);
-
-            return result;
-        }
-
-        public override async Task<QueryResponseBase> PaginateQueryAsync(IRequest<IQueryParameters> request)
-        {
-            if (null == request)
-            {
-                throw new ArgumentNullException(nameof(request));
-            }
-
-            if (null == request.Payload)
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
-            }
-
-            if (string.IsNullOrWhiteSpace(request.CorrelationIdentifier))
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidRequest);
-            }
-
-            IReadOnlyCollection<Resource> resources = await this.QueryAsync(request).ConfigureAwait(false);
-            QueryResponseBase result = new QueryResponse(resources);
-            if (null == request.Payload.PaginationParameters)
-            {
-                result.TotalResults =
-                    result.ItemsPerPage =
-                        resources.Count;
-            }
-
-            return result;
-        }
-
-        private Resource[] Query(IQueryParameters parameters)
-        {
-            if (null == parameters)
-            {
-                throw new ArgumentNullException(nameof(parameters));
-            }
-
-            if (parameters.AlternateFilters.Count != 1)
-            {
-                throw new NotSupportedException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterCount);
-            }
-
-            if (parameters.PaginationParameters != null)
-            {
-                string exceptionMessage =
-                        string.Format(
-                            CultureInfo.InvariantCulture,
-                            SystemForCrossDomainIdentityManagementServiceResources.ExceptionPaginationIsNotSupportedTemplate,
-                            parameters.SchemaIdentifier);
-                throw new NotSupportedException(exceptionMessage);
-            }
-
-            IFilter filter = parameters.AlternateFilters.Single();
-            if (filter.AdditionalFilter != null)
-            {
-                Resource[] result = SampleProvider.QueryMember(parameters, filter);
-                return result;
-            }
-            else if (string.Equals(parameters.SchemaIdentifier, SchemaIdentifiers.Core2EnterpriseUser, StringComparison.OrdinalIgnoreCase))
-            {
-                Resource[] result = this.QueryUsers(parameters, filter);
-                return result;
-            }
-            else if (string.Equals(parameters.SchemaIdentifier, SchemaIdentifiers.Core2Group, StringComparison.OrdinalIgnoreCase))
-            {
-                Resource[] result = this.QueryGroups(parameters, filter);
-                return result;
-            }
-            else
-            {
-                string exceptionMessage =
-                        string.Format(
-                            CultureInfo.InvariantCulture,
-                            SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterAttributePathNotSupportedTemplate,
-                            filter.AttributePath);
-                throw new NotSupportedException(exceptionMessage);
-            }
-        }
-
-        public override Task<Resource[]> QueryAsync(IQueryParameters parameters, string correlationIdentifier)
-        {
-            Resource[] resources = this.Query(parameters);
-            Task<Resource[]> result = Task.FromResult(resources);
-            return result;
-        }
-
-        private Resource[] QueryGroups(IQueryParameters parameters, IFilter filter)
-        {
-            if (null == parameters)
-            {
-                throw new ArgumentNullException(nameof(parameters));
-            }
-
-            if (null == filter)
-            {
-                throw new ArgumentNullException(nameof(filter));
-            }
-
-            if
-            (
-                    null == parameters.ExcludedAttributePaths
-                || !parameters.ExcludedAttributePaths.Any()
-                || parameters.ExcludedAttributePaths.Count != 1
-                || !parameters.ExcludedAttributePaths.Single().Equals(AttributeNames.Members, StringComparison.Ordinal)
-            )
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            if (
-                       !string.Equals(filter.AttributePath, AttributeNames.ExternalIdentifier, StringComparison.OrdinalIgnoreCase)
-                    && !string.Equals(filter.AttributePath, AttributeNames.DisplayName, StringComparison.OrdinalIgnoreCase)
-               )
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterAttributePathNotSupportedTemplate,
-                        filter.AttributePath);
-                throw new NotSupportedException(exceptionMessage);
-            }
-
-            if (filter.FilterOperator != ComparisonOperator.Equals)
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterOperatorNotSupportedTemplate,
-                        filter.FilterOperator);
-                throw new NotSupportedException(exceptionMessage);
-            }
-
-            Resource[] results;
-            if (!string.Equals(filter.ComparisonValue, SampleProvider.GroupName, StringComparison.OrdinalIgnoreCase))
-            {
-                results = Enumerable.Empty<Resource>().ToArray();
-            }
-            else
-            {
-                results = this.sampleGroup.ToCollection().ToArray();
-            }
-
-            return results;
-        }
-
-        private static Resource[] QueryMember(IQueryParameters parameters, IFilter filter)
-        {
-            if (null == parameters)
-            {
-                throw new ArgumentNullException(nameof(parameters));
-            }
-
-            if (null == filter)
-            {
-                throw new ArgumentNullException(nameof(filter));
-            }
-
-            if (null == filter.AdditionalFilter)
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            Resource[] results = null;
-
-            if (parameters.ExcludedAttributePaths != null && parameters.ExcludedAttributePaths.Any())
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            if (!string.Equals(parameters.SchemaIdentifier, SchemaIdentifiers.Core2Group, StringComparison.Ordinal))
-            {
-                throw new NotSupportedException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            if (null == parameters.RequestedAttributePaths || !parameters.RequestedAttributePaths.Any())
-            {
-                throw new NotSupportedException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            if (filter.AdditionalFilter.AdditionalFilter != null)
-            {
-                throw new NotSupportedException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            string selectedAttribute = parameters.RequestedAttributePaths.SingleOrDefault();
-            if (string.IsNullOrWhiteSpace(selectedAttribute))
-            {
-                throw new NotSupportedException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            if (!string.Equals(selectedAttribute, AttributeNames.Identifier, StringComparison.OrdinalIgnoreCase))
-            {
-                throw new NotSupportedException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            IReadOnlyCollection<IFilter> filters =
-                new IFilter[]
-                        {
-                            filter,
-                            filter.AdditionalFilter
-                        };
-
-            IFilter filterIdentifier =
-                filters
-                .SingleOrDefault(
-                    (IFilter item) =>
-                        item.AttributePath.Equals(AttributeNames.Identifier, StringComparison.OrdinalIgnoreCase));
-            if (null == filterIdentifier)
-            {
-                throw new NotSupportedException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            IFilter filterMembers =
-                filters
-                .SingleOrDefault(
-                    (IFilter item) =>
-                        item.AttributePath.Equals(AttributeNames.Members, StringComparison.OrdinalIgnoreCase));
-            if (null == filterMembers)
-            {
-                throw new NotSupportedException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            IResourceIdentifier containerIdentifier =
-                new ResourceIdentifier()
-                {
-                    SchemaIdentifier = parameters.SchemaIdentifier,
-                    Identifier = filterIdentifier.ComparisonValue
-                };
-
-            if (!SampleProvider.HasMember(containerIdentifier, filterMembers.AttributePath, filterMembers.ComparisonValue))
-            {
-                results = Array.Empty<Resource>();
-            }
-            else
-            {
-                Resource container =
-                    new Core2Group()
-                    {
-                        Identifier = containerIdentifier.Identifier
-                    };
-                results = container.ToCollection().ToArray();
-            }
-
-            return results;
-        }
-
-        private Resource[] QueryUsers(IQueryParameters parameters, IFilter filter)
-        {
-            if (null == parameters)
-            {
-                throw new ArgumentNullException(nameof(parameters));
-            }
-
-            if (null == filter)
-            {
-                throw new ArgumentNullException(nameof(filter));
-            }
-
-            if (parameters.ExcludedAttributePaths != null && parameters.ExcludedAttributePaths.Any())
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionQueryNotSupported);
-            }
-
-            if
-            (
-                    !string.Equals(filter.AttributePath, AttributeNames.ExternalIdentifier, StringComparison.OrdinalIgnoreCase)
-                && !string.Equals(filter.AttributePath, AttributeNames.UserName, StringComparison.OrdinalIgnoreCase)
-            )
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterAttributePathNotSupportedTemplate,
-                        filter.AttributePath);
-                throw new NotSupportedException(exceptionMessage);
-            }
-
-            if (filter.FilterOperator != ComparisonOperator.Equals)
-            {
-                string exceptionMessage =
-                    string.Format(
-                        CultureInfo.InvariantCulture,
-                        SystemForCrossDomainIdentityManagementServiceResources.ExceptionFilterOperatorNotSupportedTemplate,
-                        filter.FilterOperator);
-                throw new NotSupportedException(exceptionMessage);
-            }
-
-            Resource[] results;
-            if
-            (
-                   !string.Equals(filter.ComparisonValue, SampleProvider.IdentifierExternal, StringComparison.OrdinalIgnoreCase)
-                && !string.Equals(filter.ComparisonValue, this.SampleUser.UserName, StringComparison.OrdinalIgnoreCase)
-            )
-            {
-                results = Enumerable.Empty<Resource>().ToArray();
-            }
-            else
-            {
-                results = this.SampleUser.ToCollection().ToArray();
-            }
-
-            return results;
-        }
-
-        public override Task<Resource> ReplaceAsync(Resource resource, string correlationIdentifier)
-        {
-            if (null == resource)
-            {
-                throw new ArgumentNullException(nameof(resource));
-            }
-
-            if (null == resource.Identifier)
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidResource);
-            }
-
-            if
-            (
-                    resource.Is(SchemaIdentifiers.Core2EnterpriseUser)
-                && string.Equals(resource.Identifier, SampleProvider.IdentifierUser, StringComparison.OrdinalIgnoreCase)
-            )
-            {
-                Task<Resource> result = Task.FromResult(resource);
-                return result;
-            }
-
-            throw new HttpResponseException(HttpStatusCode.NotFound);
-        }
-
-        public override Task<Resource> RetrieveAsync(IResourceRetrievalParameters parameters, string correlationIdentifier)
-        {
-            if (null == parameters)
-            {
-                throw new ArgumentNullException(nameof(parameters));
-            }
-
-            if (null == parameters.ResourceIdentifier)
-            {
-                throw new ArgumentException(SystemForCrossDomainIdentityManagementServiceResources.ExceptionInvalidParameters);
-            }
-
-            Resource resource = null;
-            if
-            (
-                    string.Equals(
-                        parameters.ResourceIdentifier.SchemaIdentifier,
-                        SchemaIdentifiers.Core2EnterpriseUser,
-                        StringComparison.Ordinal)
-                && string.Equals(
-                        parameters.ResourceIdentifier.Identifier,
-                        SampleProvider.IdentifierUser,
-                        StringComparison.OrdinalIgnoreCase)
-            )
-            {
-                resource = this.SampleUser;
-            }
-
-            Task<Resource> result = Task.FromResult(resource);
-            return result;
-        }
-
-        public override Task UpdateAsync(IPatch patch, string correlationIdentifier)
-        {
-            if (null == patch)
-            {
-                throw new ArgumentNullException(nameof(patch));
-            }
-
-            Task result = Task.WhenAll();
-            return result;
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/SchematizedMediaTypeFormatter.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/SchematizedMediaTypeFormatter.cs
deleted file mode 100644
index 3b6795e8..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/SchematizedMediaTypeFormatter.cs
+++ /dev/null
@@ -1,337 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System;
-    using System.Collections.Generic;
-    using System.IO;
-    using System.Net;
-    using System.Net.Http;
-    using System.Net.Http.Formatting;
-    using System.Net.Http.Headers;
-    using System.Text;
-    using System.Threading;
-    using System.Threading.Tasks;
-    using System.Web.Http;
-
-    public sealed class SchematizedMediaTypeFormatter : MediaTypeFormatter
-    {
-        private static readonly Encoding Encoding = Encoding.UTF8;
-
-        private static readonly Lazy<MediaTypeHeaderValue> MediaTypeHeaderJavaWebToken =
-            new Lazy<MediaTypeHeaderValue>(
-                () =>
-                    new MediaTypeHeaderValue(MediaTypes.JavaWebToken));
-
-        private static readonly Lazy<MediaTypeHeaderValue> MediaTypeHeaderJson =
-            new Lazy<MediaTypeHeaderValue>(
-                () =>
-                    new MediaTypeHeaderValue(MediaTypes.Json));
-
-        private static readonly Lazy<MediaTypeHeaderValue> MediaTypeHeaderProtocol =
-            new Lazy<MediaTypeHeaderValue>(
-                () =>
-                    new MediaTypeHeaderValue(MediaTypes.Protocol));
-
-        private static readonly Lazy<MediaTypeHeaderValue> MediaTypeHeaderStream =
-            new Lazy<MediaTypeHeaderValue>(
-                () =>
-                    new MediaTypeHeaderValue(MediaTypes.Stream));
-
-        public SchematizedMediaTypeFormatter(
-            IMonitor monitor,
-            JsonDeserializingFactory<Schematized> deserializingFactory)
-        {
-            this.Monitor = monitor ?? throw new ArgumentNullException(nameof(monitor));
-
-            this.SupportedMediaTypes.Add(SchematizedMediaTypeFormatter.MediaTypeHeaderJavaWebToken.Value);
-            this.SupportedMediaTypes.Add(SchematizedMediaTypeFormatter.MediaTypeHeaderJson.Value);
-            this.SupportedMediaTypes.Add(SchematizedMediaTypeFormatter.MediaTypeHeaderProtocol.Value);
-            this.SupportedMediaTypes.Add(SchematizedMediaTypeFormatter.MediaTypeHeaderStream.Value);
-
-            this.DeserializingFactory = deserializingFactory ?? throw new ArgumentNullException(nameof(deserializingFactory));
-        }
-
-        private JsonDeserializingFactory<Schematized> DeserializingFactory
-        {
-            get;
-            set;
-        }
-
-        private IMonitor Monitor
-        {
-            get;
-            set;
-        }
-
-        private static bool CanProcessType(Type type)
-        {
-            Type schematizedType = typeof(Schematized);
-            bool result = schematizedType.IsAssignableFrom(type) || type == typeof(string);
-            return result;
-        }
-
-        public override bool CanReadType(Type type)
-        {
-            if (null == type)
-            {
-                throw new ArgumentNullException(nameof(type));
-            }
-
-            bool result = SchematizedMediaTypeFormatter.CanProcessType(type);
-            return result;
-        }
-
-        public override bool CanWriteType(Type type)
-        {
-            if (null == type)
-            {
-                throw new ArgumentNullException(nameof(type));
-            }
-
-            bool result = SchematizedMediaTypeFormatter.CanProcessType(type);
-            return result;
-        }
-
-        private static async Task<string> ReadFromStream(Stream readStream)
-        {
-            if (null == readStream)
-            {
-                throw new ArgumentNullException(nameof(readStream));
-            }
-
-            StreamReader reader = null;
-            try
-            {
-                reader = new StreamReader(readStream, SchematizedMediaTypeFormatter.Encoding);
-                string result = await reader.ReadToEndAsync().ConfigureAwait(false);
-                return result;
-            }
-            finally
-            {
-                if (reader != null)
-                {
-                    reader.Close();
-                    reader = null;
-                }
-            }
-        }
-
-        private async Task<object> ReadFromStream(Type type, Stream readStream, HttpContent content)
-        {
-            if (null == type)
-            {
-                throw new ArgumentNullException(nameof(type));
-            }
-
-            if (null == readStream)
-            {
-                throw new ArgumentNullException(nameof(readStream));
-            }
-
-            if
-            (
-                    !typeof(IDictionary<string, object>).IsAssignableFrom(type)
-                && !typeof(Schematized).IsAssignableFrom(type)
-                && typeof(string) != type
-            )
-            {
-                throw new NotSupportedException(type.FullName);
-            }
-
-            string characters = await SchematizedMediaTypeFormatter.ReadFromStream(readStream).ConfigureAwait(false);
-            string information = string.Concat(SystemForCrossDomainIdentityManagementServiceResources.InformationRead, characters);
-            IInformationNotification notification =
-                InformationNotificationFactory.Instance.CreateNotification(
-                    information,
-                    null,
-                    ServiceNotificationIdentifiers.SchematizedMediaTypeFormatterReadFromStream);
-            this.Monitor.Inform(notification);
-
-            if
-            (
-                    string.Equals(
-                        content?.Headers?.ContentType?.MediaType,
-                        MediaTypes.JavaWebToken,
-                        StringComparison.Ordinal)
-            )
-            {
-                return characters;
-            }
-
-            Dictionary<string, object> json =
-                JsonFactory.Instance.Create(
-                    characters,
-                    this.DeserializingFactory.AcceptLargeObjects);
-            if (typeof(IDictionary<string, object>).IsAssignableFrom(type))
-            {
-                return json;
-            }
-
-            try
-            {
-                Schematized result = this.DeserializingFactory.Create(json);
-                return result;
-            }
-            catch (ArgumentException)
-            {
-                return new HttpResponseException(HttpStatusCode.BadRequest);
-            }
-            catch (NotSupportedException)
-            {
-                return new HttpResponseException(HttpStatusCode.BadRequest);
-            }
-#pragma warning disable CA1031 // Do not catch general exception types
-            catch
-            {
-                return new HttpResponseException(HttpStatusCode.BadRequest);
-            }
-#pragma warning restore CA1031 // Do not catch general exception types
-        }
-
-        public override Task<object> ReadFromStreamAsync(
-            Type type,
-            Stream readStream,
-            HttpContent content,
-            IFormatterLogger formatterLogger)
-        {
-            if (null == type)
-            {
-                throw new ArgumentNullException(nameof(type));
-            }
-
-            if (null == readStream)
-            {
-                throw new ArgumentNullException(nameof(readStream));
-            }
-
-            Task<object> result = this.ReadFromStream(type, readStream, content);
-            return result;
-        }
-
-        public override Task<object> ReadFromStreamAsync(
-            Type type,
-            Stream readStream,
-            HttpContent content,
-            IFormatterLogger formatterLogger,
-            CancellationToken cancellationToken)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            return this.ReadFromStreamAsync(type, readStream, content, formatterLogger);
-        }
-
-        private async Task WriteToStream(
-            Type type,
-            object value,
-            Stream writeStream,
-            Func<byte[], Task> writeFunction)
-        {
-            if (null == type)
-            {
-                throw new ArgumentNullException(nameof(type));
-            }
-
-            if (null == value)
-            {
-                throw new ArgumentNullException(nameof(value));
-            }
-
-            if (null == writeStream)
-            {
-                throw new ArgumentNullException(nameof(writeStream));
-            }
-
-            string characters;
-            if (typeof(string) == type)
-            {
-                characters = (string)value;
-            }
-            else
-            {
-                IDictionary<string, object> json;
-                if (typeof(IDictionary<string, object>).IsAssignableFrom(type))
-                {
-                    json = (IDictionary<string, object>)value;
-                    characters = JsonFactory.Instance.Create(json, this.DeserializingFactory.AcceptLargeObjects);
-                }
-                else if (typeof(Schematized).IsAssignableFrom(type))
-                {
-                    Schematized schematized = (Schematized)value;
-                    json = schematized.ToJson();
-                    characters = JsonFactory.Instance.Create(json, this.DeserializingFactory.AcceptLargeObjects);
-                }
-                else
-                {
-                    throw new NotSupportedException(type.FullName);
-                }
-            }
-            string information =
-                string.Concat(
-                    SystemForCrossDomainIdentityManagementServiceResources.InformationWrote,
-                    characters);
-            IInformationNotification notification =
-                InformationNotificationFactory.Instance.CreateNotification(
-                    information,
-                    null,
-                    ServiceNotificationIdentifiers.SchematizedMediaTypeFormatterWroteToStream);
-            this.Monitor.Inform(notification);
-            byte[] bytes = SchematizedMediaTypeFormatter.Encoding.GetBytes(characters);
-            await writeFunction(bytes).ConfigureAwait(false);
-            writeStream.Flush();
-        }
-
-        public override Task WriteToStreamAsync(
-            Type type,
-            object value,
-            Stream writeStream,
-            HttpContent content,
-            TransportContext transportContext)
-        {
-            if (null == type)
-            {
-                throw new ArgumentNullException(nameof(type));
-            }
-
-            if (null == writeStream)
-            {
-                throw new ArgumentNullException(nameof(writeStream));
-            }
-
-            Func<byte[], Task> writeFunction =
-                new Func<byte[], Task>(
-                    async (byte[] buffer) =>
-                        await writeStream.WriteAsync(buffer, 0, buffer.Length).ConfigureAwait(false));
-            Task result = this.WriteToStream(type, value, writeStream, writeFunction);
-            return result;
-        }
-
-        public override Task WriteToStreamAsync(
-            Type type,
-            object value,
-            Stream writeStream,
-            HttpContent content,
-            TransportContext transportContext,
-            CancellationToken cancellationToken)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-
-            if (null == type)
-            {
-                throw new ArgumentNullException(nameof(type));
-            }
-
-            if (null == writeStream)
-            {
-                throw new ArgumentNullException(nameof(writeStream));
-            }
-
-            Func<byte[], Task> writeFunction =
-                new Func<byte[], Task>(
-                    async (byte[] buffer) =>
-                        await writeStream.WriteAsync(buffer, 0, buffer.Length, cancellationToken).ConfigureAwait(false));
-            Task result = this.WriteToStream(type, value, writeStream, writeFunction);
-            return result;
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/SystemForCrossDomainIdentityManagementRequest.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/SystemForCrossDomainIdentityManagementRequest.cs
index 870c05c7..7b799fdf 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/SystemForCrossDomainIdentityManagementRequest.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/Service/SystemForCrossDomainIdentityManagementRequest.cs
@@ -4,20 +4,20 @@ namespace Microsoft.SCIM
 {
     using System;
     using System.Collections.Generic;
-    using System.Net.Http;
+    using Microsoft.AspNetCore.Http;
 
-    public abstract class SystemForCrossDomainIdentityManagementRequest<TPayload> : IRequest<TPayload>
+    public class SystemForCrossDomainIdentityManagementRequest<TPayload> : IRequest<TPayload>
         where TPayload : class
     {
-        protected SystemForCrossDomainIdentityManagementRequest(
-            HttpRequestMessage request,
+        public SystemForCrossDomainIdentityManagementRequest(
+            HttpContext context,
             TPayload payload,
             string correlationIdentifier,
             IReadOnlyCollection<IExtension> extensions)
         {
-            if (null == request)
+            if (null == context)
             {
-                throw new ArgumentNullException(nameof(request));
+                throw new ArgumentNullException(nameof(context));
             }
 
             if (string.IsNullOrWhiteSpace(correlationIdentifier))
@@ -25,8 +25,8 @@ protected SystemForCrossDomainIdentityManagementRequest(
                 throw new ArgumentNullException(nameof(extensions));
             }
 
-            this.BaseResourceIdentifier = request.GetBaseResourceIdentifier();
-            this.Request = request;
+            this.BaseResourceIdentifier = context.GetBaseResourceIdentifier();
+            this.HttpContext = context;
             this.Payload = payload ?? throw new ArgumentNullException(nameof(payload));
             this.CorrelationIdentifier = correlationIdentifier;
             this.Extensions = extensions;
@@ -56,7 +56,7 @@ public TPayload Payload
             private set;
         }
 
-        public HttpRequestMessage Request
+        public HttpContext HttpContext
         {
             get;
             private set;
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/Service/UpdateRequest.cs b/Microsoft.SystemForCrossDomainIdentityManagement/Service/UpdateRequest.cs
deleted file mode 100644
index 469333a0..00000000
--- a/Microsoft.SystemForCrossDomainIdentityManagement/Service/UpdateRequest.cs
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) Microsoft Corporation.// Licensed under the MIT license.
-
-namespace Microsoft.SCIM
-{
-    using System.Collections.Generic;
-    using System.Net.Http;
-
-    public sealed class UpdateRequest :
-        SystemForCrossDomainIdentityManagementRequest<IPatch>
-    {
-        public UpdateRequest(
-            HttpRequestMessage request,
-            IPatch payload,
-            string correlationIdentifier,
-            IReadOnlyCollection<IExtension> extensions)
-            : base(request, payload, correlationIdentifier, extensions)
-        {
-        }
-    }
-}
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/SystemForCrossDomainIdentityManagementServiceResources.Designer.cs b/Microsoft.SystemForCrossDomainIdentityManagement/SystemForCrossDomainIdentityManagementServiceResources.Designer.cs
index d1de25bc..cad85013 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/SystemForCrossDomainIdentityManagementServiceResources.Designer.cs
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/SystemForCrossDomainIdentityManagementServiceResources.Designer.cs
@@ -363,5 +363,11 @@ public static string WarningUnexpectedWatermarkTemplate {
                 return ResourceManager.GetString("WarningUnexpectedWatermarkTemplate", resourceCulture);
             }
         }
+        
+        public static string ExceptionResourceConflict {
+            get {
+                return ResourceManager.GetString("ExceptionResourceConflict", resourceCulture);
+            }
+        }
     }
 }
diff --git a/Microsoft.SystemForCrossDomainIdentityManagement/SystemForCrossDomainIdentityManagementServiceResources.resx b/Microsoft.SystemForCrossDomainIdentityManagement/SystemForCrossDomainIdentityManagementServiceResources.resx
index 738c314b..f24d8560 100644
--- a/Microsoft.SystemForCrossDomainIdentityManagement/SystemForCrossDomainIdentityManagementServiceResources.resx
+++ b/Microsoft.SystemForCrossDomainIdentityManagement/SystemForCrossDomainIdentityManagementServiceResources.resx
@@ -223,4 +223,7 @@ Supplied:
 Received: 
 {1}</value>
   </data>
+  <data name="ExceptionResourceConflict" xml:space="preserve">
+    <value>The specified version number does not match the resource's latest version number, or a service provider refused to create a new, duplicate resource.</value>
+  </data>
 </root>
\ No newline at end of file