diff --git a/.gitignore b/.gitignore
index 743f7e47..5ddc16d5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,7 @@
 *.user
 *.userosscache
 *.sln.docstates
+*.bak
 
 # Build results
 [Dd]ebug/
diff --git a/Deepgram.Tests/Fakes/ConcreteRestClient.cs b/Deepgram.Tests/Fakes/ConcreteRestClient.cs
index f1fa2748..5c8b7ddb 100644
--- a/Deepgram.Tests/Fakes/ConcreteRestClient.cs
+++ b/Deepgram.Tests/Fakes/ConcreteRestClient.cs
@@ -1,4 +1,4 @@
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram.Tests.Fakes;
 
diff --git a/Deepgram.Tests/GlobalSuppressions.cs b/Deepgram.Tests/GlobalSuppressions.cs
index 435078d8..64acd118 100644
--- a/Deepgram.Tests/GlobalSuppressions.cs
+++ b/Deepgram.Tests/GlobalSuppressions.cs
@@ -6,17 +6,17 @@
 using System.Diagnostics.CodeAnalysis;
 
 [assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.LiveClientTests.GetBaseUrl_Should_Return_WSS_Protocol_When_DeepgramClientOptions_BaseAddress_Contains_No_Protocol")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.OnPremClientTests.CreateCredentials_Should_Return_OnPremCredentialsResponse~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.OnPremClientTests.GetCredentials_Should_Call_GetAsync_Returning_OnPremCredentialsResponse~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.OnPremClientTests.ListCredentials_Should_Call_GetAsync_Returning_ListOnPremCredentialsResponse~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFile_With_Bytes_Should_Call_PostAsync_Returning_SyncPrerecordedResponse~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFile_With_Stream_Should_Call_PostAsync_Returning_SyncPrerecordedResponse~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFileCallBack_With_Bytes_With_CallBack_Parameter_Should_Call_PostAsync_Returning_SyncPrerecordedResponse~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFileCallBack_With_Bytes_With_CallBack_Property_Should_Call_PostAsync_Returning_SyncPrerecordedResponse~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFileCallBack_With_Stream_With_CallBack_Parameter_Should_Call_PostAsync_Returning_SyncPrerecordedResponse~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFileCallBack_With_Stream_With_CallBack_Property_Should_Call_PostAsync_Returning_SyncPrerecordedResponse~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeUrl_Should_Call_PostAsync_Returning_SyncPrerecordedResponse~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncPrerecordedResponse_With_CallBack_Parameter~System.Threading.Tasks.Task")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncPrerecordedResponse_With_CallBack_Property~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.OnPremClientTests.CreateCredentials_Should_Return_CredentialResponse~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.OnPremClientTests.GetCredentials_Should_Call_GetAsync_Returning_CredentialResponse~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.OnPremClientTests.ListCredentials_Should_Call_GetAsync_Returning_CredentialsResponse~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFile_With_Bytes_Should_Call_PostAsync_Returning_SyncResponse~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFile_With_Stream_Should_Call_PostAsync_Returning_SyncResponse~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFileCallBack_With_Bytes_With_CallBack_Parameter_Should_Call_PostAsync_Returning_SyncResponse~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFileCallBack_With_Bytes_With_CallBack_Property_Should_Call_PostAsync_Returning_SyncResponse~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFileCallBack_With_Stream_With_CallBack_Parameter_Should_Call_PostAsync_Returning_SyncResponse~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeFileCallBack_With_Stream_With_CallBack_Property_Should_Call_PostAsync_Returning_SyncResponse~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeUrl_Should_Call_PostAsync_Returning_SyncResponse~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncResponse_With_CallBack_Parameter~System.Threading.Tasks.Task")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests.TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncResponse_With_CallBack_Property~System.Threading.Tasks.Task")]
 [assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Tests.UnitTests.ClientTests.OnPremClientTests")]
 [assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Tests.UnitTests.ClientTests.PrerecordedClientTests")]
diff --git a/Deepgram.Tests/UnitTests/ClientTests/AbstractRestClientTests.cs b/Deepgram.Tests/UnitTests/ClientTests/AbstractRestClientTests.cs
index 571117d3..cd5d6f5e 100644
--- a/Deepgram.Tests/UnitTests/ClientTests/AbstractRestClientTests.cs
+++ b/Deepgram.Tests/UnitTests/ClientTests/AbstractRestClientTests.cs
@@ -1,7 +1,7 @@
-using Deepgram.DeepgramHttpClient;
+using Deepgram.Encapsulations;
 using Deepgram.Models.Manage.v1;
 using Deepgram.Models.PreRecorded.v1;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram.Tests.UnitTests.ClientTests;
 
@@ -22,12 +22,12 @@ public void Setup()
     public void GetAsync_Should_Throws_HttpRequestException_On_UnsuccessfulResponse()
     {
         // Arrange       
-        var expectedResponse = new AutoFaker<GetProjectsResponse>().Generate();
+        var expectedResponse = new AutoFaker<ProjectsResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithException(new HttpRequestException());
 
         var client = new ConcreteRestClient(_apiKey, _clientOptions) { _httpClientWrapper = new HttpClientWrapper(httpClient) };
         // Act & Assert
-        client.Invoking(y => y.GetAsync<GetProjectsResponse>(UriSegments.PROJECTS))
+        client.Invoking(y => y.GetAsync<ProjectsResponse>(UriSegments.PROJECTS))
              .Should().ThrowAsync<HttpRequestException>();
     }
 
@@ -35,12 +35,12 @@ public void GetAsync_Should_Throws_HttpRequestException_On_UnsuccessfulResponse(
     public void GetAsync_Should_Throws_Exception_On_UnsuccessfulResponse()
     {
         // Arrange       
-        var expectedResponse = new AutoFaker<GetProjectsResponse>().Generate();
+        var expectedResponse = new AutoFaker<ProjectsResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithException(new Exception());
 
         var client = new ConcreteRestClient(_apiKey, _clientOptions) { _httpClientWrapper = new HttpClientWrapper(httpClient) };
         // Act & Assert
-        client.Invoking(y => y.GetAsync<GetProjectsResponse>(UriSegments.PROJECTS))
+        client.Invoking(y => y.GetAsync<ProjectsResponse>(UriSegments.PROJECTS))
              .Should().ThrowAsync<Exception>();
     }
 
@@ -49,14 +49,14 @@ public void GetAsync_Should_Throws_Exception_On_UnsuccessfulResponse()
     public void PostAsync_Which_Handles_HttpContent_Should_Throw_Exception_On_UnsuccessfulResponse()
     {
         // Arrange       
-        var response = new AutoFaker<SyncPrerecordedResponse>().Generate();
+        var response = new AutoFaker<SyncResponse>().Generate();
         var httpContent = Substitute.For<HttpContent>();
         var httpClient = MockHttpClient.CreateHttpClientWithException(new Exception());
 
         var client = new ConcreteRestClient(_apiKey, _clientOptions) { _httpClientWrapper = new HttpClientWrapper(httpClient) };
 
         // Act & Assert      
-        client.Invoking(y => y.PostAsync<SyncPrerecordedResponse>(UriSegments.PROJECTS, httpContent))
+        client.Invoking(y => y.PostAsync<SyncResponse>(UriSegments.PROJECTS, httpContent))
              .Should().ThrowAsync<Exception>();
     }
 
@@ -65,7 +65,7 @@ public void PostAsync_Which_Handles_HttpContent_Should_Throw_Exception_On_Unsucc
     public void PostAsync_Which_Handles_HttpContent_Should_Throw_HttpRequestException_On_UnsuccessfulResponse()
     {
         // Arrange       
-        var response = new AutoFaker<SyncPrerecordedResponse>().Generate();
+        var response = new AutoFaker<SyncResponse>().Generate();
         var httpContent = Substitute.For<HttpContent>();
         var httpClient = MockHttpClient.CreateHttpClientWithException(new HttpRequestException());
         var client = new ConcreteRestClient(_apiKey, _clientOptions)
@@ -74,7 +74,7 @@ public void PostAsync_Which_Handles_HttpContent_Should_Throw_HttpRequestExceptio
         };
 
         // Act & Assert      
-        client.Invoking(y => y.PostAsync<SyncPrerecordedResponse>(UriSegments.PROJECTS, httpContent))
+        client.Invoking(y => y.PostAsync<SyncResponse>(UriSegments.PROJECTS, httpContent))
              .Should().ThrowAsync<HttpRequestException>();
     }
 
@@ -83,14 +83,14 @@ public void PostAsync_Which_Handles_HttpContent_Should_Throw_HttpRequestExceptio
     public void PostAsync_Should_Throw_Exception_On_UnsuccessfulResponse()
     {
         // Arrange       
-        var response = new AutoFaker<SyncPrerecordedResponse>().Generate();
+        var response = new AutoFaker<SyncResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithException(new Exception());
 
         var client = new ConcreteRestClient(_apiKey, _clientOptions) { _httpClientWrapper = new HttpClientWrapper(httpClient) };
 
         // Act & Assert  
         client.Invoking(y =>
-        y.PostAsync<SyncPrerecordedResponse>(UriSegments.PROJECTS, new StringContent(string.Empty)))
+        y.PostAsync<SyncResponse>(UriSegments.PROJECTS, new StringContent(string.Empty)))
              .Should().ThrowAsync<Exception>();
     }
 
@@ -98,14 +98,14 @@ public void PostAsync_Should_Throw_Exception_On_UnsuccessfulResponse()
     public void PostAsync_Should_Throw_HttpRequestException_On_UnsuccessfulResponse()
     {
         // Arrange       
-        var response = new AutoFaker<SyncPrerecordedResponse>().Generate();
+        var response = new AutoFaker<SyncResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithException(new HttpRequestException());
 
         var client = new ConcreteRestClient(_apiKey, _clientOptions) { _httpClientWrapper = new HttpClientWrapper(httpClient) };
 
         // Act & Assert      
         client.Invoking(y =>
-        y.PostAsync<SyncPrerecordedResponse>(UriSegments.PROJECTS, new StringContent(string.Empty)))
+        y.PostAsync<SyncResponse>(UriSegments.PROJECTS, new StringContent(string.Empty)))
              .Should().ThrowAsync<HttpRequestException>();
     }
 
diff --git a/Deepgram.Tests/UnitTests/ClientTests/LiveClientTests.cs b/Deepgram.Tests/UnitTests/ClientTests/LiveClientTests.cs
index f41e5c1c..1a6a86d6 100644
--- a/Deepgram.Tests/UnitTests/ClientTests/LiveClientTests.cs
+++ b/Deepgram.Tests/UnitTests/ClientTests/LiveClientTests.cs
@@ -1,7 +1,7 @@
 using System.Net.WebSockets;
 using Deepgram.DeepgramEventArgs;
 using Deepgram.Models.Live.v1;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram.Tests.UnitTests.ClientTests;
 public class LiveClientTests
@@ -25,17 +25,17 @@ public void Teardown()
     { _liveClient.Dispose(); }
 
     [Test]
-    public void ProcessDataReceived_Should_Raise_TranscriptReceived_Event_When_Response_Contains_Type_LiveTranscriptionResponse()
+    public void ProcessDataReceived_Should_Raise_TranscriptReceived_Event_When_Response_Contains_Type_TranscriptionResponse()
     {
         //Arrange
-        var liveTranscriptionResponse = new AutoFaker<LiveTranscriptionResponse>().Generate();
+        var liveTranscriptionResponse = new AutoFaker<TranscriptionResponse>().Generate();
         // ensure the right type is set for testing
         liveTranscriptionResponse.Type = Enums.LiveType.Results;
         var json = JsonSerializer.Serialize(liveTranscriptionResponse);
         var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
-        LiveResponseReceivedEventArgs? eventArgs = null;
+        ResponseReceivedEventArgs? eventArgs = null;
 
-        _liveClient.LiveResponseReceived += (sender, args) => eventArgs = args;
+        _liveClient.EventResponseReceived += (sender, args) => eventArgs = args;
 
 
         //Act
@@ -45,22 +45,22 @@ public void ProcessDataReceived_Should_Raise_TranscriptReceived_Event_When_Respo
 
         eventArgs.Should().NotBeNull();
         eventArgs!.Response.Transcription.Should().NotBeNull();
-        eventArgs.Response.Transcription.Should().BeAssignableTo<LiveTranscriptionResponse>();
+        eventArgs.Response.Transcription.Should().BeAssignableTo<TranscriptionResponse>();
     }
 
     [Test]
-    public void ProcessDataReceived_Should_Raise_MetaDataReceived_Event_When_Response_Contains_Type_LiveMetadataResponse()
+    public void ProcessDataReceived_Should_Raise_MetaDataReceived_Event_When_Response_Contains_Type_MetadataResponse()
     {
         //Arrange
-        var liveMetadataResponse = new AutoFaker<LiveMetadataResponse>().Generate();
+        var liveMetadataResponse = new AutoFaker<MetadataResponse>().Generate();
         // ensure the right type is set for testing
         liveMetadataResponse.Type = Enums.LiveType.Metadata;
         var json = JsonSerializer.Serialize(liveMetadataResponse);
         var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
 
-        LiveResponseReceivedEventArgs? eventArgs = null;
+        ResponseReceivedEventArgs? eventArgs = null;
 
-        _liveClient.LiveResponseReceived += (sender, args) => eventArgs = args;
+        _liveClient.EventResponseReceived += (sender, args) => eventArgs = args;
 
         //Act
         _liveClient.ProcessDataReceived(_webSocketReceiveResult, memoryStream);
@@ -70,7 +70,7 @@ public void ProcessDataReceived_Should_Raise_MetaDataReceived_Event_When_Respons
         {
             eventArgs.Should().NotBeNull();
             eventArgs!.Response.MetaData.Should().NotBeNull();
-            eventArgs.Response.MetaData.Should().BeAssignableTo<LiveMetadataResponse>();
+            eventArgs.Response.MetaData.Should().BeAssignableTo<MetadataResponse>();
         }
     }
 
@@ -82,9 +82,9 @@ public void ProcessDataReceived_Should_Raise_LiveError_Event_When_Response_Conta
         var json = JsonSerializer.Serialize(unknownDataResponse);
         var memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(json));
 
-        LiveResponseReceivedEventArgs? eventArgs = null;
+        ResponseReceivedEventArgs? eventArgs = null;
 
-        _liveClient.LiveResponseReceived += (sender, args) => eventArgs = args;
+        _liveClient.EventResponseReceived += (sender, args) => eventArgs = args;
 
         //Act
         _liveClient.ProcessDataReceived(_webSocketReceiveResult, memoryStream);
diff --git a/Deepgram.Tests/UnitTests/ClientTests/ManageClientTest.cs b/Deepgram.Tests/UnitTests/ClientTests/ManageClientTest.cs
index 97e3920f..ecb5b686 100644
--- a/Deepgram.Tests/UnitTests/ClientTests/ManageClientTest.cs
+++ b/Deepgram.Tests/UnitTests/ClientTests/ManageClientTest.cs
@@ -1,7 +1,7 @@
-using Deepgram.DeepgramHttpClient;
+using Deepgram.Encapsulations;
 using Deepgram.Models.Manage;
 using Deepgram.Models.Manage.v1;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram.Tests.UnitTests.ClientTests;
 public class ManageClientTest
@@ -23,55 +23,55 @@ public void Setup()
 
 
     [Test]
-    public async Task GetProjects_Should_Call_GetAsync_Returning_GetProjectsResponse()
+    public async Task GetProjects_Should_Call_GetAsync_Returning_ProjectsResponse()
     {
         // Arrange
-        var expectedResponse = new AutoFaker<GetProjectsResponse>().Generate();
+        var expectedResponse = new AutoFaker<ProjectsResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
 
-        manageClient.When(x => x.GetAsync<GetProjectsResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectsResponse>(UriSegments.PROJECTS).Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<ProjectsResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<ProjectsResponse>(UriSegments.PROJECTS).Returns(expectedResponse);
 
         // Act
         var result = await manageClient.GetProjects();
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectsResponse>(UriSegments.PROJECTS);
+        await manageClient.Received().GetAsync<ProjectsResponse>(UriSegments.PROJECTS);
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectsResponse>();
+            result.Should().BeAssignableTo<ProjectsResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
 
         }
     }
 
     [Test]
-    public async Task GetProject_Should_Call_GetAsync_Returning_GetProjectResponse()
+    public async Task GetProject_Should_Call_GetAsync_Returning_ProjectResponse()
     {
 
         // Arrange
-        var expectedResponse = new AutoFaker<GetProjectResponse>().Generate();
+        var expectedResponse = new AutoFaker<ProjectResponse>().Generate();
         expectedResponse.ProjectId = _projectId;
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectResponse>($"{UriSegments.PROJECTS}/{_projectId}").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<ProjectResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<ProjectResponse>($"{UriSegments.PROJECTS}/{_projectId}").Returns(expectedResponse);
 
         // Act
         var result = await manageClient.GetProject(_projectId);
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectResponse>($"projects/{_projectId}");
+        await manageClient.Received().GetAsync<ProjectResponse>($"projects/{_projectId}");
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectResponse>();
+            result.Should().BeAssignableTo<ProjectResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
@@ -81,7 +81,7 @@ public async Task UpdateProject_Should_Call_PatchAsync_Returning_MessageResponse
     {
         //Arrange 
         var expectedResponse = new AutoFaker<MessageResponse>().Generate();
-        var updateProjectSchema = new AutoFaker<UpdateProjectSchema>().Generate();
+        var updateProjectSchema = new AutoFaker<ProjectSchema>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
@@ -150,71 +150,71 @@ public async Task DeleteProject_Should_Call_DeleteAsync()
 
     #region ProjectKeys
     [Test]
-    public async Task GetProjectKeys_Should_Call_GetAsync_Returning_GetProjectKeysResponse()
+    public async Task GetProjectKeys_Should_Call_GetAsync_Returning_KeysResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<GetProjectKeysResponse>().Generate();
+        var expectedResponse = new AutoFaker<KeysResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectKeysResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectKeysResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<KeysResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<KeysResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys").Returns(expectedResponse);
 
         //Act
         var result = await manageClient.GetProjectKeys(_projectId);
 
         //Assert
-        await manageClient.Received().GetAsync<GetProjectKeysResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys");
+        await manageClient.Received().GetAsync<KeysResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys");
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectKeysResponse>();
+            result.Should().BeAssignableTo<KeysResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task GetProjectKey_Should_Call_GetAsync_Returning_GetProjectKeyResponse()
+    public async Task GetProjectKey_Should_Call_GetAsync_Returning_KeyResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<GetProjectKeyResponse>().Generate();
+        var expectedResponse = new AutoFaker<KeyScopeResponse>().Generate();
         var keyId = new Faker().Random.Guid().ToString();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectKeyResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectKeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys/{keyId}").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<KeyScopeResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<KeyScopeResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys/{keyId}").Returns(expectedResponse);
 
 
         //Act
         var result = await manageClient.GetProjectKey(_projectId, keyId);
-        await manageClient.Received().GetAsync<GetProjectKeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys/{keyId}");
+        await manageClient.Received().GetAsync<KeyScopeResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys/{keyId}");
 
         //Assert
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectKeyResponse>();
+            result.Should().BeAssignableTo<KeyScopeResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task CreateProjectKey_Should_Call_PostAsync_Returning_CreateProjectKeyResponse_Without_Expiration_TimeToLive_Set()
+    public async Task CreateProjectKey_Should_Call_PostAsync_Returning_KeyResponse_Without_Expiration_TimeToLive_Set()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<CreateProjectKeyResponse>().Generate();
-        var createKeySchema = new AutoFaker<CreateProjectKeySchema>().Generate();
+        var expectedResponse = new AutoFaker<KeyResponse>().Generate();
+        var createKeySchema = new AutoFaker<KeySchema>().Generate();
         createKeySchema.ExpirationDate = null;
         createKeySchema.TimeToLiveInSeconds = null;
 
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.PostAsync<CreateProjectKeyResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
-        manageClient.PostAsync<CreateProjectKeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>()).Returns(expectedResponse);
+        manageClient.When(x => x.PostAsync<KeyResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
+        manageClient.PostAsync<KeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>()).Returns(expectedResponse);
 
 
 
@@ -222,29 +222,29 @@ public async Task CreateProjectKey_Should_Call_PostAsync_Returning_CreateProject
         var result = await manageClient.CreateProjectKey(_projectId, createKeySchema);
 
         //Assert
-        await manageClient.Received().PostAsync<CreateProjectKeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>());
+        await manageClient.Received().PostAsync<KeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>());
 
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<CreateProjectKeyResponse>();
+            result.Should().BeAssignableTo<KeyResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task CreateProjectKey_Should_Call_PostAsync_Returning_CreateProjectKeyResponse_With_Expiration_Set()
+    public async Task CreateProjectKey_Should_Call_PostAsync_Returning_KeyResponse_With_Expiration_Set()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<CreateProjectKeyResponse>().Generate();
-        var createKeySchema = new AutoFaker<CreateProjectKeySchema>().Generate();
+        var expectedResponse = new AutoFaker<KeyResponse>().Generate();
+        var createKeySchema = new AutoFaker<KeySchema>().Generate();
         createKeySchema.TimeToLiveInSeconds = null;
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.PostAsync<CreateProjectKeyResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
-        manageClient.PostAsync<CreateProjectKeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>()).Returns(expectedResponse);
+        manageClient.When(x => x.PostAsync<KeyResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
+        manageClient.PostAsync<KeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>()).Returns(expectedResponse);
 
 
 
@@ -252,40 +252,40 @@ public async Task CreateProjectKey_Should_Call_PostAsync_Returning_CreateProject
         var result = await manageClient.CreateProjectKey(_projectId, createKeySchema);
 
         //Assert
-        await manageClient.Received().PostAsync<CreateProjectKeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>());
+        await manageClient.Received().PostAsync<KeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>());
 
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<CreateProjectKeyResponse>();
+            result.Should().BeAssignableTo<KeyResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task CreateProjectKey_Should_Return_CreateProjectKeyResponse_Without_TimeToLive_Set()
+    public async Task CreateProjectKey_Should_Return_KeyResponse_Without_TimeToLive_Set()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<CreateProjectKeyResponse>().Generate();
-        var createKeySchema = new AutoFaker<CreateProjectKeySchema>().Generate();
+        var expectedResponse = new AutoFaker<KeyResponse>().Generate();
+        var createKeySchema = new AutoFaker<KeySchema>().Generate();
         createKeySchema.ExpirationDate = null;
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.PostAsync<CreateProjectKeyResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
-        manageClient.PostAsync<CreateProjectKeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>()).Returns(expectedResponse);
+        manageClient.When(x => x.PostAsync<KeyResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
+        manageClient.PostAsync<KeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>()).Returns(expectedResponse);
 
         //Act
         var result = await manageClient.CreateProjectKey(_projectId, createKeySchema);
 
         //Assert
-        await manageClient.Received().PostAsync<CreateProjectKeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>());
+        await manageClient.Received().PostAsync<KeyResponse>($"{UriSegments.PROJECTS}/{_projectId}/keys", Arg.Any<StringContent>());
 
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<CreateProjectKeyResponse>();
+            result.Should().BeAssignableTo<KeyResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
@@ -294,7 +294,7 @@ public async Task CreateProjectKey_Should_Return_CreateProjectKeyResponse_Withou
     public async Task CreateProjectKey_Should_Throw_ArgumentException_When_Both_Expiration_And_TimeToLive_Set()
     {
         //Arrange 
-        var createKeySchema = new AutoFaker<CreateProjectKeySchema>().Generate();
+        var createKeySchema = new AutoFaker<KeySchema>().Generate();
 
         var manageClient = new ManageClient(_apiKey, _options) { _httpClientWrapper = new HttpClientWrapper(new HttpClient()) };
 
@@ -327,26 +327,26 @@ public async Task DeleteProjectKey_Should_Call_DeleteAsync()
     #region ProjectInvites
 
     [Test]
-    public async Task GetProjectInvites_Should_Call_GetAsync_Returning_GetProjectInvitesResponse()
+    public async Task GetProjectInvites_Should_Call_GetAsync_Returning_InvitesResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<GetProjectInvitesResponse>().Generate();
+        var expectedResponse = new AutoFaker<InvitesResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectInvitesResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectInvitesResponse>($"{UriSegments.PROJECTS}/{_projectId}/invites").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<InvitesResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<InvitesResponse>($"{UriSegments.PROJECTS}/{_projectId}/invites").Returns(expectedResponse);
 
         // Act
         var result = await manageClient.GetProjectInvites(_projectId);
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectInvitesResponse>($"{UriSegments.PROJECTS}/{_projectId}/invites");
+        await manageClient.Received().GetAsync<InvitesResponse>($"{UriSegments.PROJECTS}/{_projectId}/invites");
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectInvitesResponse>();
+            result.Should().BeAssignableTo<InvitesResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
@@ -356,7 +356,7 @@ public async Task SendProjectInvite_Should_Call_PostAsync_Returning_MessageRespo
     {
         //Arrange 
         var expectedResponse = new AutoFaker<MessageResponse>().Generate();
-        var sendProjectInviteSchema = new AutoFaker<SendProjectInviteSchema>().Generate();
+        var inviteSchema = new AutoFaker<InviteSchema>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
@@ -365,7 +365,7 @@ public async Task SendProjectInvite_Should_Call_PostAsync_Returning_MessageRespo
         manageClient.PostAsync<MessageResponse>($"{UriSegments.PROJECTS}/{_projectId}/invites", Arg.Any<StringContent>()).Returns(expectedResponse);
 
         // Act
-        var result = await manageClient.SendProjectInvite(_projectId, sendProjectInviteSchema);
+        var result = await manageClient.SendProjectInvite(_projectId, inviteSchema);
 
         // Assert
         await manageClient.Received().PostAsync<MessageResponse>($"{UriSegments.PROJECTS}/{_projectId}/invites", Arg.Any<StringContent>());
@@ -400,53 +400,53 @@ public async Task DeleteProjectInvite_Should_Call_DeleteAsync()
 
     #region Members
     [Test]
-    public async Task GetProjectMembers_Should_Call_GetAsync_Returning_GetProjectMembersResponse()
+    public async Task GetProjectMembers_Should_Call_GetAsync_Returning_MembersResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<GetProjectMembersResponse>().Generate();
+        var expectedResponse = new AutoFaker<MembersResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectMembersResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectMembersResponse>($"{UriSegments.PROJECTS}/{_projectId}/members").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<MembersResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<MembersResponse>($"{UriSegments.PROJECTS}/{_projectId}/members").Returns(expectedResponse);
 
         // Act
         var result = await manageClient.GetProjectMembers(_projectId);
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectMembersResponse>($"{UriSegments.PROJECTS}/{_projectId}/members");
+        await manageClient.Received().GetAsync<MembersResponse>($"{UriSegments.PROJECTS}/{_projectId}/members");
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectMembersResponse>();
+            result.Should().BeAssignableTo<MembersResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task GetProjectMemberScopes_Should_Call_GetAsync_Returning_GetProjectMemberScopesResponse()
+    public async Task GetProjectMemberScopes_Should_Call_GetAsync_Returning_MemberScopesResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<GetProjectMemberScopesResponse>().Generate();
+        var expectedResponse = new AutoFaker<MemberScopesResponse>().Generate();
         var memberId = new Faker().Random.Guid().ToString();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectMemberScopesResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectMemberScopesResponse>($"{UriSegments.PROJECTS}/{_projectId}/members/{memberId}/scopes").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<MemberScopesResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<MemberScopesResponse>($"{UriSegments.PROJECTS}/{_projectId}/members/{memberId}/scopes").Returns(expectedResponse);
 
         // Act
         var result = await manageClient.GetProjectMemberScopes(_projectId, memberId);
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectMemberScopesResponse>($"{UriSegments.PROJECTS}/{_projectId}/members/{memberId}/scopes");
+        await manageClient.Received().GetAsync<MemberScopesResponse>($"{UriSegments.PROJECTS}/{_projectId}/members/{memberId}/scopes");
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectMemberScopesResponse>();
+            result.Should().BeAssignableTo<MemberScopesResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
@@ -456,7 +456,7 @@ public async Task UpdateProjectMemberScope_Should_Call_PutAsync_Returning_Messag
     {
         //Arrange 
         var expectedResponse = new AutoFaker<MessageResponse>().Generate();
-        var updateProjectMemberScopeSchema = new AutoFaker<UpdateProjectMemberScopeSchema>().Generate();
+        var memberScopeSchema = new AutoFaker<MemberScopeSchema>().Generate();
         var memberId = new Faker().Random.Guid().ToString();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
@@ -466,7 +466,7 @@ public async Task UpdateProjectMemberScope_Should_Call_PutAsync_Returning_Messag
         manageClient.PutAsync<MessageResponse>($"{UriSegments.PROJECTS}/{_projectId}/members/{memberId}/scopes", Arg.Any<StringContent>()).Returns(expectedResponse);
 
         // Act
-        var result = await manageClient.UpdateProjectMemberScope(_projectId, memberId, updateProjectMemberScopeSchema);
+        var result = await manageClient.UpdateProjectMemberScope(_projectId, memberId, memberScopeSchema);
 
         // Assert
         await manageClient.Received().PutAsync<MessageResponse>($"{UriSegments.PROJECTS}/{_projectId}/members/{memberId}/scopes", Arg.Any<StringContent>());
@@ -501,111 +501,111 @@ public async Task RemoveProjectMember_Should_Call_DeleteAsync()
 
     #region Usage
     [Test]
-    public async Task GetProjectUsageRequests_Should_Call_GetAsync_Returning_GetProjectUsageRequestsResponse()
+    public async Task GetProjectUsageRequests_Should_Call_GetAsync_Returning_UsageRequestsResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<GetProjectUsageRequestsResponse>().Generate();
-        var getProjectUsageRequestsSchema = new AutoFaker<GetProjectUsageRequestsSchema>().Generate();
-        var stringedOptions = QueryParameterUtil.GetParameters(getProjectUsageRequestsSchema);
+        var expectedResponse = new AutoFaker<UsageRequestsResponse>().Generate();
+        var UsageRequestsSchema = new AutoFaker<UsageRequestsSchema>().Generate();
+        var stringedOptions = QueryParameterUtil.GetParameters(UsageRequestsSchema);
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectUsageRequestsResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectUsageRequestsResponse>($"{UriSegments.PROJECTS}/{_projectId}/requests?{stringedOptions}").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<UsageRequestsResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<UsageRequestsResponse>($"{UriSegments.PROJECTS}/{_projectId}/requests?{stringedOptions}").Returns(expectedResponse);
 
         // Act
-        var result = await manageClient.GetProjectUsageRequests(_projectId, getProjectUsageRequestsSchema);
+        var result = await manageClient.GetProjectUsageRequests(_projectId, UsageRequestsSchema);
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectUsageRequestsResponse>($"{UriSegments.PROJECTS}/{_projectId}/requests?{stringedOptions}");
+        await manageClient.Received().GetAsync<UsageRequestsResponse>($"{UriSegments.PROJECTS}/{_projectId}/requests?{stringedOptions}");
 
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectUsageRequestsResponse>();
+            result.Should().BeAssignableTo<UsageRequestsResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task GetProjectsUsageRequest_Should_Call_GetAsync_Returning_GetProjectUsageRequestResponse()
+    public async Task GetProjectsUsageRequest_Should_Call_GetAsync_Returning_UsageRequestResponse()
     {
         //Arrange 
         var requestId = new Faker().Random.Guid().ToString();
-        var expectedResponse = new AutoFaker<GetProjectUsageRequestResponse>().Generate();
+        var expectedResponse = new AutoFaker<UsageRequestResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectUsageRequestResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectUsageRequestResponse>($"{UriSegments.PROJECTS}/{_projectId}/requests/{requestId}").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<UsageRequestResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<UsageRequestResponse>($"{UriSegments.PROJECTS}/{_projectId}/requests/{requestId}").Returns(expectedResponse);
 
         // Act
         var result = await manageClient.GetProjectUsageRequest(_projectId, requestId);
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectUsageRequestResponse>($"{UriSegments.PROJECTS}/{_projectId}/requests/{requestId}");
+        await manageClient.Received().GetAsync<UsageRequestResponse>($"{UriSegments.PROJECTS}/{_projectId}/requests/{requestId}");
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectUsageRequestResponse>();
+            result.Should().BeAssignableTo<UsageRequestResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task GetProjectsUsageSummary_Should_Call_GetAsync_Returning_GetProjectUsageSummaryResponse()
+    public async Task GetProjectsUsageSummary_Should_Call_GetAsync_Returning_UsageSummaryResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<GetProjectUsageSummaryResponse>().Generate();
-        var getProjectUsageSummarySchema = new AutoFaker<GetProjectsUsageSummarySchema>().Generate();
+        var expectedResponse = new AutoFaker<UsageSummaryResponse>().Generate();
+        var getProjectUsageSummarySchema = new AutoFaker<UsageSummarySchema>().Generate();
         var stringedOptions = QueryParameterUtil.GetParameters(getProjectUsageSummarySchema);
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectUsageSummaryResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectUsageSummaryResponse>($"{UriSegments.PROJECTS}/{_projectId}/usage?{stringedOptions}").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<UsageSummaryResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<UsageSummaryResponse>($"{UriSegments.PROJECTS}/{_projectId}/usage?{stringedOptions}").Returns(expectedResponse);
 
         // Act
         var result = await manageClient.GetProjectUsageSummary(_projectId, getProjectUsageSummarySchema);
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectUsageSummaryResponse>($"{UriSegments.PROJECTS}/{_projectId}/usage?{stringedOptions}");
+        await manageClient.Received().GetAsync<UsageSummaryResponse>($"{UriSegments.PROJECTS}/{_projectId}/usage?{stringedOptions}");
 
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectUsageSummaryResponse>();
+            result.Should().BeAssignableTo<UsageSummaryResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task GetProjectUsageFields_Should_GetAsync_Returning_GetProjectUsageSummaryResponse()
+    public async Task GetProjectUsageFields_Should_GetAsync_Returning_UsageSummaryResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<GetProjectUsageFieldsResponse>().Generate();
-        var getProjectUsageFieldsSchema = new AutoFaker<GetProjectUsageFieldsSchema>().Generate();
+        var expectedResponse = new AutoFaker<UsageFieldsResponse>().Generate();
+        var getProjectUsageFieldsSchema = new AutoFaker<UsageFieldsSchema>().Generate();
         var stringedOptions = QueryParameterUtil.GetParameters(getProjectUsageFieldsSchema);
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectUsageFieldsResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectUsageFieldsResponse>($"{UriSegments.PROJECTS}/{_projectId}/usage/fields?{stringedOptions}").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<UsageFieldsResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<UsageFieldsResponse>($"{UriSegments.PROJECTS}/{_projectId}/usage/fields?{stringedOptions}").Returns(expectedResponse);
 
         // Act
         var result = await manageClient.GetProjectUsageFields(_projectId, getProjectUsageFieldsSchema);
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectUsageFieldsResponse>($"{UriSegments.PROJECTS}/{_projectId}/usage/fields?{stringedOptions}");
+        await manageClient.Received().GetAsync<UsageFieldsResponse>($"{UriSegments.PROJECTS}/{_projectId}/usage/fields?{stringedOptions}");
 
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectUsageFieldsResponse>();
+            result.Should().BeAssignableTo<UsageFieldsResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
@@ -615,51 +615,51 @@ public async Task GetProjectUsageFields_Should_GetAsync_Returning_GetProjectUsag
     #region Balances
 
     [Test]
-    public async Task GetProjectBalances_Should_Call_GetAsync_Returning_GetProjectBalancesResponse()
+    public async Task GetProjectBalances_Should_Call_GetAsync_Returning_BalancesResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<GetProjectBalancesResponse>().Generate();
+        var expectedResponse = new AutoFaker<BalancesResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        manageClient.When(x => x.GetAsync<GetProjectBalancesResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectBalancesResponse>($"{UriSegments.PROJECTS}/{_projectId}/balances").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<BalancesResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<BalancesResponse>($"{UriSegments.PROJECTS}/{_projectId}/balances").Returns(expectedResponse);
 
         // Act
         var result = await manageClient.GetProjectBalances(_projectId);
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectBalancesResponse>($"{UriSegments.PROJECTS}/{_projectId}/balances");
+        await manageClient.Received().GetAsync<BalancesResponse>($"{UriSegments.PROJECTS}/{_projectId}/balances");
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectBalancesResponse>();
+            result.Should().BeAssignableTo<BalancesResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task GetProjectBalance_Should_Call_GetAsync_Returning_GetProjectBalanceResponse()
+    public async Task GetProjectBalance_Should_Call_GetAsync_Returning_BalanceResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<GetProjectBalanceResponse>().Generate();
+        var expectedResponse = new AutoFaker<BalanceResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
         var manageClient = Substitute.For<ManageClient>(_apiKey, _options);
         manageClient._httpClientWrapper = new HttpClientWrapper(httpClient);
         var balanceId = new Faker().Random.Guid().ToString();
-        manageClient.When(x => x.GetAsync<GetProjectBalanceResponse>(Arg.Any<string>())).DoNotCallBase();
-        manageClient.GetAsync<GetProjectBalanceResponse>($"{UriSegments.PROJECTS}/{_projectId}/balances/{balanceId}").Returns(expectedResponse);
+        manageClient.When(x => x.GetAsync<BalanceResponse>(Arg.Any<string>())).DoNotCallBase();
+        manageClient.GetAsync<BalanceResponse>($"{UriSegments.PROJECTS}/{_projectId}/balances/{balanceId}").Returns(expectedResponse);
 
         // Act
         var result = await manageClient.GetProjectBalance(_projectId, balanceId);
 
         // Assert
-        await manageClient.Received().GetAsync<GetProjectBalanceResponse>($"{UriSegments.PROJECTS}/{_projectId}/balances/{balanceId}");
+        await manageClient.Received().GetAsync<BalanceResponse>($"{UriSegments.PROJECTS}/{_projectId}/balances/{balanceId}");
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<GetProjectBalanceResponse>();
+            result.Should().BeAssignableTo<BalanceResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
diff --git a/Deepgram.Tests/UnitTests/ClientTests/OnPremClientTests.cs b/Deepgram.Tests/UnitTests/ClientTests/OnPremClientTests.cs
index fb19a377..4912a1c4 100644
--- a/Deepgram.Tests/UnitTests/ClientTests/OnPremClientTests.cs
+++ b/Deepgram.Tests/UnitTests/ClientTests/OnPremClientTests.cs
@@ -1,7 +1,7 @@
-using Deepgram.DeepgramHttpClient;
+using Deepgram.Encapsulations;
 using Deepgram.Models.Manage.v1;
 using Deepgram.Models.OnPrem.v1;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram.Tests.UnitTests.ClientTests;
 public class OnPremClientTests
@@ -21,54 +21,54 @@ public void Setup()
 
 
     [Test]
-    public async Task ListCredentials_Should_Call_GetAsync_Returning_ListOnPremCredentialsResponse()
+    public async Task ListCredentials_Should_Call_GetAsync_Returning_CredentialsResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<ListOnPremCredentialsResponse>().Generate();
+        var expectedResponse = new AutoFaker<CredentialsResponse>().Generate();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var onPremClient = Substitute.For<OnPremClient>(_apiKey, _options);
         onPremClient._httpClientWrapper = new HttpClientWrapper(httpClient);
 
-        onPremClient.When(x => x.GetAsync<ListOnPremCredentialsResponse>(Arg.Any<string>())).DoNotCallBase();
-        onPremClient.GetAsync<ListOnPremCredentialsResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}").Returns(expectedResponse);
+        onPremClient.When(x => x.GetAsync<CredentialsResponse>(Arg.Any<string>())).DoNotCallBase();
+        onPremClient.GetAsync<CredentialsResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}").Returns(expectedResponse);
 
         // Act
 
         var result = await onPremClient.ListCredentials(_projectId);
 
         // Assert
-        await onPremClient.Received().GetAsync<ListOnPremCredentialsResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}");
+        await onPremClient.Received().GetAsync<CredentialsResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}");
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<ListOnPremCredentialsResponse>();
+            result.Should().BeAssignableTo<CredentialsResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task GetCredentials_Should_Call_GetAsync_Returning_OnPremCredentialsResponse()
+    public async Task GetCredentials_Should_Call_GetAsync_Returning_CredentialResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<OnPremCredentialsResponse>().Generate();
+        var expectedResponse = new AutoFaker<CredentialResponse>().Generate();
         var credentialsId = new Faker().Random.Guid().ToString();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var onPremClient = Substitute.For<OnPremClient>(_apiKey, _options);
         onPremClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        onPremClient.When(x => x.GetAsync<OnPremCredentialsResponse>(Arg.Any<string>())).DoNotCallBase();
-        onPremClient.GetAsync<OnPremCredentialsResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}/{credentialsId}").Returns(expectedResponse);
+        onPremClient.When(x => x.GetAsync<CredentialResponse>(Arg.Any<string>())).DoNotCallBase();
+        onPremClient.GetAsync<CredentialResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}/{credentialsId}").Returns(expectedResponse);
 
         // Act
         var result = await onPremClient.GetCredentials(_projectId, credentialsId);
 
         // Assert
-        await onPremClient.Received().GetAsync<OnPremCredentialsResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}/{credentialsId}");
+        await onPremClient.Received().GetAsync<CredentialResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}/{credentialsId}");
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<OnPremCredentialsResponse>();
+            result.Should().BeAssignableTo<CredentialResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
@@ -102,29 +102,29 @@ public async Task DeleteCredentials_Should_Call_DeleteAsync_Returning_MessageRes
 
 
     [Test]
-    public async Task CreateCredentials_Should_Return_OnPremCredentialsResponse()
+    public async Task CreateCredentials_Should_Return_CredentialResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<OnPremCredentialsResponse>().Generate();
-        var createOnPremCredentialsSchema = new CreateOnPremCredentialsSchema();
+        var expectedResponse = new AutoFaker<CredentialResponse>().Generate();
+        var createOnPremCredentialsSchema = new CredentialsSchema();
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
 
         var onPremClient = Substitute.For<OnPremClient>(_apiKey, _options);
         onPremClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        onPremClient.When(x => x.PostAsync<OnPremCredentialsResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
-        onPremClient.PostAsync<OnPremCredentialsResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}", Arg.Any<StringContent>()).Returns(expectedResponse);
+        onPremClient.When(x => x.PostAsync<CredentialResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
+        onPremClient.PostAsync<CredentialResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}", Arg.Any<StringContent>()).Returns(expectedResponse);
 
         // Act
 
         var result = await onPremClient.CreateCredentials(_projectId, createOnPremCredentialsSchema);
 
         // Assert
-        await onPremClient.Received().PostAsync<OnPremCredentialsResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}", Arg.Any<StringContent>());
+        await onPremClient.Received().PostAsync<CredentialResponse>($"{UriSegments.PROJECTS}/{_projectId}/{UriSegments.ONPREM}", Arg.Any<StringContent>());
 
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<OnPremCredentialsResponse>();
+            result.Should().BeAssignableTo<CredentialResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
diff --git a/Deepgram.Tests/UnitTests/ClientTests/PrerecordedClientTests.cs b/Deepgram.Tests/UnitTests/ClientTests/PrerecordedClientTests.cs
index 6b551e81..c72cb654 100644
--- a/Deepgram.Tests/UnitTests/ClientTests/PrerecordedClientTests.cs
+++ b/Deepgram.Tests/UnitTests/ClientTests/PrerecordedClientTests.cs
@@ -1,6 +1,6 @@
-using Deepgram.DeepgramHttpClient;
+using Deepgram.Encapsulations;
 using Deepgram.Models.PreRecorded.v1;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram.Tests.UnitTests.ClientTests;
 public class PrerecordedClientTests
@@ -16,10 +16,10 @@ public void Setup()
     }
 
     [Test]
-    public async Task TranscribeUrl_Should_Call_PostAsync_Returning_SyncPrerecordedResponse()
+    public async Task TranscribeUrl_Should_Call_PostAsync_Returning_SyncResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<SyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<SyncResponse>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         prerecordedSchema.CallBack = null;
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
@@ -29,19 +29,19 @@ public async Task TranscribeUrl_Should_Call_PostAsync_Returning_SyncPrerecordedR
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
 
-        prerecordedClient.When(x => x.PostAsync<SyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<SyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<SyncResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<SyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>()).Returns(expectedResponse);
 
         // Act
         var result = await prerecordedClient.TranscribeUrl(source, prerecordedSchema);
 
         // Assert
-        await prerecordedClient.Received().PostAsync<SyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>());
+        await prerecordedClient.Received().PostAsync<SyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>());
 
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<SyncPrerecordedResponse>();
+            result.Should().BeAssignableTo<SyncResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
@@ -50,7 +50,7 @@ public async Task TranscribeUrl_Should_Call_PostAsync_Returning_SyncPrerecordedR
     public async Task TranscribeUrl_Should_Throw_ArgumentException_If_CallBack_Not_Null()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<SyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<SyncResponse>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
         var source = new AutoFaker<UrlSource>().Generate();
@@ -58,21 +58,21 @@ public async Task TranscribeUrl_Should_Throw_ArgumentException_If_CallBack_Not_N
 
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<SyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<SyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<SyncResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<SyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>()).Returns(expectedResponse);
 
         // Act and Assert
         await prerecordedClient.Invoking(y => y.TranscribeUrl(source, prerecordedSchema))
             .Should().ThrowAsync<ArgumentException>();
 
-        await prerecordedClient.DidNotReceive().PostAsync<SyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>());
+        await prerecordedClient.DidNotReceive().PostAsync<SyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>());
     }
 
     [Test]
-    public async Task TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncPrerecordedResponse_With_CallBack_Parameter()
+    public async Task TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncResponse_With_CallBack_Parameter()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<AsyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<AsyncResponse>().Generate();
         var source = new AutoFaker<UrlSource>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         // prerecordedSchema is not null here as we first need to get the querystring with the callBack included
@@ -81,8 +81,8 @@ public async Task TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncPrer
 
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<AsyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<AsyncResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>()).Returns(expectedResponse);
         var callBackParameter = prerecordedSchema.CallBack;
         //before we act to test this call with the callBack parameter and not the callBack property we need to null the callBack property
         prerecordedSchema.CallBack = null;
@@ -92,20 +92,20 @@ public async Task TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncPrer
         var result = await prerecordedClient.TranscribeUrlCallBack(source, callBackParameter, prerecordedSchema);
 
         // Assert
-        await prerecordedClient.Received().PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>());
+        await prerecordedClient.Received().PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>());
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<AsyncPrerecordedResponse>();
+            result.Should().BeAssignableTo<AsyncResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncPrerecordedResponse_With_CallBack_Property()
+    public async Task TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncResponse_With_CallBack_Property()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<AsyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<AsyncResponse>().Generate();
         var source = new AutoFaker<UrlSource>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         var stringedQuery = QueryParameterUtil.GetParameters(prerecordedSchema);
@@ -113,18 +113,18 @@ public async Task TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncPrer
 
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<AsyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<AsyncResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>()).Returns(expectedResponse);
 
         // Act
         var result = await prerecordedClient.TranscribeUrlCallBack(source, null, prerecordedSchema);
 
         // Assert
-        await prerecordedClient.Received().PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>());
+        await prerecordedClient.Received().PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>());
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<AsyncPrerecordedResponse>();
+            result.Should().BeAssignableTo<AsyncResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
@@ -133,7 +133,7 @@ public async Task TranscribeUrlCallBack_Should_Call_PostAsync_Returning_SyncPrer
     public async Task TranscribeUrlCallBack_Should_Throw_ArgumentException_With_CallBack_Property_And_CallBack_Parameter_Set()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<AsyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<AsyncResponse>().Generate();
         var source = new AutoFaker<UrlSource>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         var stringedQuery = QueryParameterUtil.GetParameters(prerecordedSchema);
@@ -141,22 +141,22 @@ public async Task TranscribeUrlCallBack_Should_Throw_ArgumentException_With_Call
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<AsyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<AsyncResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>()).Returns(expectedResponse);
         var callBackParameter = prerecordedSchema.CallBack;
 
         // Act Assert
         await prerecordedClient.Invoking(y => y.TranscribeUrlCallBack(source, callBackParameter, prerecordedSchema))
             .Should().ThrowAsync<ArgumentException>();
 
-        await prerecordedClient.DidNotReceive().PostAsync<SyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>());
+        await prerecordedClient.DidNotReceive().PostAsync<SyncResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>());
     }
 
     [Test]
     public async Task TranscribeUrlCallBack_Should_Throw_ArgumentException_With_No_CallBack_Set()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<AsyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<AsyncResponse>().Generate();
         var source = new AutoFaker<UrlSource>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         prerecordedSchema.CallBack = null;
@@ -165,22 +165,22 @@ public async Task TranscribeUrlCallBack_Should_Throw_ArgumentException_With_No_C
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<AsyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<AsyncResponse>(Arg.Any<string>(), Arg.Any<StringContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>()).Returns(expectedResponse);
 
 
         // Act Assert
         await prerecordedClient.Invoking(y => y.TranscribeUrlCallBack(source, null, prerecordedSchema))
             .Should().ThrowAsync<ArgumentException>();
 
-        await prerecordedClient.DidNotReceive().PostAsync<SyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>());
+        await prerecordedClient.DidNotReceive().PostAsync<SyncResponse>($"{UriSegments.LISTEN}?{stringedQuery}", Arg.Any<StringContent>());
     }
 
     [Test]
-    public async Task TranscribeFile_With_Stream_Should_Call_PostAsync_Returning_SyncPrerecordedResponse()
+    public async Task TranscribeFile_With_Stream_Should_Call_PostAsync_Returning_SyncResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<SyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<SyncResponse>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         prerecordedSchema.CallBack = null;
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
@@ -189,27 +189,27 @@ public async Task TranscribeFile_With_Stream_Should_Call_PostAsync_Returning_Syn
 
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<SyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<SyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<SyncResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<SyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
 
         // Act
         var result = await prerecordedClient.TranscribeFile(source, prerecordedSchema);
 
         // Assert
-        await prerecordedClient.Received().PostAsync<SyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
+        await prerecordedClient.Received().PostAsync<SyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<SyncPrerecordedResponse>();
+            result.Should().BeAssignableTo<SyncResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task TranscribeFile_With_Bytes_Should_Call_PostAsync_Returning_SyncPrerecordedResponse()
+    public async Task TranscribeFile_With_Bytes_Should_Call_PostAsync_Returning_SyncResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<SyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<SyncResponse>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         prerecordedSchema.CallBack = null;
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
@@ -218,27 +218,27 @@ public async Task TranscribeFile_With_Bytes_Should_Call_PostAsync_Returning_Sync
 
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<SyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<SyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<SyncResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<SyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
 
         // Act
         var result = await prerecordedClient.TranscribeFile(source, prerecordedSchema);
 
         // Assert
-        await prerecordedClient.Received().PostAsync<SyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
+        await prerecordedClient.Received().PostAsync<SyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<SyncPrerecordedResponse>();
+            result.Should().BeAssignableTo<SyncResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task TranscribeFileCallBack_With_Stream_With_CallBack_Property_Should_Call_PostAsync_Returning_SyncPrerecordedResponse()
+    public async Task TranscribeFileCallBack_With_Stream_With_CallBack_Property_Should_Call_PostAsync_Returning_SyncResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<AsyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<AsyncResponse>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
         var source = GetFakeStream(GetFakeByteArray());
@@ -246,27 +246,27 @@ public async Task TranscribeFileCallBack_With_Stream_With_CallBack_Property_Shou
 
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<AsyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<AsyncResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
 
         // Act
         var result = await prerecordedClient.TranscribeFileCallBack(source, null, prerecordedSchema);
 
         // Assert
-        await prerecordedClient.Received().PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
+        await prerecordedClient.Received().PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<AsyncPrerecordedResponse>();
+            result.Should().BeAssignableTo<AsyncResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task TranscribeFileCallBack_With_Bytes_With_CallBack_Property_Should_Call_PostAsync_Returning_SyncPrerecordedResponse()
+    public async Task TranscribeFileCallBack_With_Bytes_With_CallBack_Property_Should_Call_PostAsync_Returning_SyncResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<AsyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<AsyncResponse>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
         var source = GetFakeByteArray();
@@ -274,28 +274,28 @@ public async Task TranscribeFileCallBack_With_Bytes_With_CallBack_Property_Shoul
 
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<AsyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<AsyncResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
 
         // Act
         var result = await prerecordedClient.TranscribeFileCallBack(source, null, prerecordedSchema);
 
         // Assert
-        await prerecordedClient.Received().PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
+        await prerecordedClient.Received().PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
 
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<AsyncPrerecordedResponse>();
+            result.Should().BeAssignableTo<AsyncResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task TranscribeFileCallBack_With_Stream_With_CallBack_Parameter_Should_Call_PostAsync_Returning_SyncPrerecordedResponse()
+    public async Task TranscribeFileCallBack_With_Stream_With_CallBack_Parameter_Should_Call_PostAsync_Returning_SyncResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<AsyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<AsyncResponse>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         // prerecordedSchema is not null here as we first need to get the querystring with the callBack included
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
@@ -304,8 +304,8 @@ public async Task TranscribeFileCallBack_With_Stream_With_CallBack_Parameter_Sho
 
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<AsyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<AsyncResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
 
         var callBack = prerecordedSchema.CallBack;
 
@@ -316,20 +316,20 @@ public async Task TranscribeFileCallBack_With_Stream_With_CallBack_Parameter_Sho
         var result = await prerecordedClient.TranscribeFileCallBack(source, callBack, prerecordedSchema);
 
         // Assert
-        await prerecordedClient.Received().PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
+        await prerecordedClient.Received().PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<AsyncPrerecordedResponse>();
+            result.Should().BeAssignableTo<AsyncResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
 
     [Test]
-    public async Task TranscribeFileCallBack_With_Bytes_With_CallBack_Parameter_Should_Call_PostAsync_Returning_SyncPrerecordedResponse()
+    public async Task TranscribeFileCallBack_With_Bytes_With_CallBack_Parameter_Should_Call_PostAsync_Returning_SyncResponse()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<AsyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<AsyncResponse>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         // prerecordedSchema is not null here as we first need to get the querystring with the callBack included
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
@@ -338,8 +338,8 @@ public async Task TranscribeFileCallBack_With_Bytes_With_CallBack_Parameter_Shou
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<AsyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<AsyncResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
 
         var callBack = prerecordedSchema.CallBack;
 
@@ -350,11 +350,11 @@ public async Task TranscribeFileCallBack_With_Bytes_With_CallBack_Parameter_Shou
         var result = await prerecordedClient.TranscribeFileCallBack(source, callBack, prerecordedSchema);
 
         // Assert
-        await prerecordedClient.Received().PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
+        await prerecordedClient.Received().PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>());
         using (new AssertionScope())
         {
             result.Should().NotBeNull();
-            result.Should().BeAssignableTo<AsyncPrerecordedResponse>();
+            result.Should().BeAssignableTo<AsyncResponse>();
             result.Should().BeEquivalentTo(expectedResponse);
         }
     }
@@ -363,7 +363,7 @@ public async Task TranscribeFileCallBack_With_Bytes_With_CallBack_Parameter_Shou
     public async Task TranscribeFileCallBack_With_Stream_Throw_ArgumentException_With_CallBack_Property_And_CallBack_Parameter_Set()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<AsyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<AsyncResponse>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
         var source = GetFakeStream(GetFakeByteArray());
@@ -371,8 +371,8 @@ public async Task TranscribeFileCallBack_With_Stream_Throw_ArgumentException_Wit
 
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<AsyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<AsyncResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
         var callBack = prerecordedSchema.CallBack;
 
 
@@ -380,7 +380,7 @@ public async Task TranscribeFileCallBack_With_Stream_Throw_ArgumentException_Wit
         await prerecordedClient.Invoking(y => y.TranscribeFileCallBack(source, callBack, prerecordedSchema))
            .Should().ThrowAsync<ArgumentException>();
 
-        await prerecordedClient.DidNotReceive().PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>());
+        await prerecordedClient.DidNotReceive().PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>());
 
 
     }
@@ -389,7 +389,7 @@ await prerecordedClient.Invoking(y => y.TranscribeFileCallBack(source, callBack,
     public async Task TranscribeFileCallBack_With_Bytes_Should_Throw_ArgumentException_With_No_CallBack_Set()
     {
         //Arrange 
-        var expectedResponse = new AutoFaker<AsyncPrerecordedResponse>().Generate();
+        var expectedResponse = new AutoFaker<AsyncResponse>().Generate();
         var prerecordedSchema = new AutoFaker<PrerecordedSchema>().Generate();
         // prerecordedSchema is not null here as we first need to get the querystring with the callBack included
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
@@ -398,15 +398,15 @@ public async Task TranscribeFileCallBack_With_Bytes_Should_Throw_ArgumentExcepti
         var httpClient = MockHttpClient.CreateHttpClientWithResult(expectedResponse);
         var prerecordedClient = Substitute.For<PrerecordedClient>(_apiKey, _options);
         prerecordedClient._httpClientWrapper = new HttpClientWrapper(httpClient);
-        prerecordedClient.When(x => x.PostAsync<AsyncPrerecordedResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
-        prerecordedClient.PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
+        prerecordedClient.When(x => x.PostAsync<AsyncResponse>(Arg.Any<string>(), Arg.Any<HttpContent>())).DoNotCallBase();
+        prerecordedClient.PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<HttpContent>()).Returns(expectedResponse);
         prerecordedSchema.CallBack = null;
 
         // Act  Assert
         await prerecordedClient.Invoking(y => y.TranscribeFileCallBack(source, null, prerecordedSchema))
            .Should().ThrowAsync<ArgumentException>();
 
-        await prerecordedClient.DidNotReceive().PostAsync<AsyncPrerecordedResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>());
+        await prerecordedClient.DidNotReceive().PostAsync<AsyncResponse>($"{UriSegments.LISTEN}?{stringedOptions}", Arg.Any<StringContent>());
     }
 
     private static Stream GetFakeStream(byte[] source)
diff --git a/Deepgram.Tests/UnitTests/ExtensionsTests/HttpClientExtensionTests.cs b/Deepgram.Tests/UnitTests/ExtensionsTests/HttpClientExtensionTests.cs
index 82697802..6f038e5a 100644
--- a/Deepgram.Tests/UnitTests/ExtensionsTests/HttpClientExtensionTests.cs
+++ b/Deepgram.Tests/UnitTests/ExtensionsTests/HttpClientExtensionTests.cs
@@ -1,5 +1,5 @@
 using Deepgram.Models.Manage.v1;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram.Tests.UnitTests.ExtensionsTests;
 public class HttpClientExtensionTests
diff --git a/Deepgram.Tests/UnitTests/UtilitiesTests/QueryParameterUtilTests.cs b/Deepgram.Tests/UnitTests/UtilitiesTests/QueryParameterUtilTests.cs
index b76bc24f..c59fac01 100644
--- a/Deepgram.Tests/UnitTests/UtilitiesTests/QueryParameterUtilTests.cs
+++ b/Deepgram.Tests/UnitTests/UtilitiesTests/QueryParameterUtilTests.cs
@@ -116,7 +116,7 @@ public void GetParameters_Should_Return_String_When_Passing_Boolean_Parameter()
     public void GetParameters_Should_Return_String_When_Passing_DateTime_Parameter()
     {
         //Arrange 
-        var options = new AutoFaker<CreateProjectKeySchema>().Generate();
+        var options = new AutoFaker<KeySchema>().Generate();
         var time = DateTime.Now;
         options.ExpirationDate = time;
 
diff --git a/Deepgram/Abstractions/AbstractRestClient.cs b/Deepgram/Abstractions/AbstractRestClient.cs
index 9d27d479..8cf9659e 100644
--- a/Deepgram/Abstractions/AbstractRestClient.cs
+++ b/Deepgram/Abstractions/AbstractRestClient.cs
@@ -1,5 +1,5 @@
-using Deepgram.DeepgramHttpClient;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Encapsulations;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram.Abstractions;
 
@@ -22,7 +22,7 @@ public abstract class AbstractRestClient
     internal AbstractRestClient(string apiKey, DeepgramClientOptions? deepgramClientOptions = null)
     {
         deepgramClientOptions ??= new DeepgramClientOptions();
-        _httpClientWrapper = DeepgramHttpClientFactory.Create(apiKey, deepgramClientOptions);
+        _httpClientWrapper = HttpClientFactory.Create(apiKey, deepgramClientOptions);
     }
 
     /// <summary>
diff --git a/Deepgram/DeepgramEventArgs/LiveResposneReceivedEventArgs.cs b/Deepgram/DeepgramEventArgs/LiveResposneReceivedEventArgs.cs
deleted file mode 100644
index 246b572d..00000000
--- a/Deepgram/DeepgramEventArgs/LiveResposneReceivedEventArgs.cs
+++ /dev/null
@@ -1,9 +0,0 @@
-using Deepgram.Models.Live.v1;
-
-namespace Deepgram.DeepgramEventArgs
-{
-    public class LiveResponseReceivedEventArgs(LiveResponse response) : EventArgs
-    {
-        public LiveResponse Response { get; set; } = response;
-    }
-}
diff --git a/Deepgram/DeepgramHttpClient/DeepgramHttpClientFactory.cs b/Deepgram/Encapsulations/HttpClientFactory.cs
similarity index 86%
rename from Deepgram/DeepgramHttpClient/DeepgramHttpClientFactory.cs
rename to Deepgram/Encapsulations/HttpClientFactory.cs
index 55133c0c..da85399f 100644
--- a/Deepgram/DeepgramHttpClient/DeepgramHttpClientFactory.cs
+++ b/Deepgram/Encapsulations/HttpClientFactory.cs
@@ -1,8 +1,8 @@
 using Deepgram.Extensions;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
-namespace Deepgram.DeepgramHttpClient;
-internal class DeepgramHttpClientFactory
+namespace Deepgram.Encapsulations;
+internal class HttpClientFactory
 {
     public static HttpClientWrapper Create(string apiKey, DeepgramClientOptions deepgramClientOptions)
     {
diff --git a/Deepgram/DeepgramHttpClient/HttpClientWrapper.cs b/Deepgram/Encapsulations/HttpClientWrapper.cs
similarity index 93%
rename from Deepgram/DeepgramHttpClient/HttpClientWrapper.cs
rename to Deepgram/Encapsulations/HttpClientWrapper.cs
index 79804cc0..a18100d6 100644
--- a/Deepgram/DeepgramHttpClient/HttpClientWrapper.cs
+++ b/Deepgram/Encapsulations/HttpClientWrapper.cs
@@ -1,10 +1,9 @@
-namespace Deepgram.DeepgramHttpClient;
+namespace Deepgram.Encapsulations;
 
 internal class HttpClientWrapper(HttpClient HttpClient)
 {
     internal Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken = default)
     {
-
         return HttpClient.SendAsync(request, cancellationToken);
     }
 
diff --git a/Deepgram/EventArgs/ResponseReceivedEventArgs.cs b/Deepgram/EventArgs/ResponseReceivedEventArgs.cs
new file mode 100644
index 00000000..f971a0b4
--- /dev/null
+++ b/Deepgram/EventArgs/ResponseReceivedEventArgs.cs
@@ -0,0 +1,9 @@
+using Deepgram.Models.Live.v1;
+
+namespace Deepgram.DeepgramEventArgs;
+
+public class ResponseReceivedEventArgs(EventResponse response) : EventArgs
+{
+    public EventResponse Response { get; set; } = response;
+}
+
diff --git a/Deepgram/Extensions/ClientWebSocketExtensions.cs b/Deepgram/Extensions/ClientWebSocketExtensions.cs
index ecfb27fb..3db60035 100644
--- a/Deepgram/Extensions/ClientWebSocketExtensions.cs
+++ b/Deepgram/Extensions/ClientWebSocketExtensions.cs
@@ -1,4 +1,4 @@
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram.Extensions;
 public static class ClientWebSocketExtensions
diff --git a/Deepgram/Extensions/HttpClientExtensions.cs b/Deepgram/Extensions/HttpClientExtensions.cs
index f9b5ed4b..3e060115 100644
--- a/Deepgram/Extensions/HttpClientExtensions.cs
+++ b/Deepgram/Extensions/HttpClientExtensions.cs
@@ -1,4 +1,4 @@
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram.Extensions;
 
diff --git a/Deepgram/GlobalSuppressions.cs b/Deepgram/GlobalSuppressions.cs
index bd42656b..b9efa119 100644
--- a/Deepgram/GlobalSuppressions.cs
+++ b/Deepgram/GlobalSuppressions.cs
@@ -8,24 +8,26 @@
 [assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~F:Deepgram.Constants.AudioEncoding.OggSpeex")]
 [assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "namespace", Target = "~N:Deepgram.DeepgramEventArgs")]
 [assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~P:Deepgram.Models.Manage.v1.Config.Diarize")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~P:Deepgram.Models.Manage.v1.GetProjectsUsageSummarySchema.Diarize")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.OnPrem.v1.CreateOnPremCredentialsSchema")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.OnPrem.v1.ListOnPremCredentialsResponse")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.OnPrem.v1.OnPremCredentialsResponse")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.PreRecorded.v1.AsyncPrerecordedResponse")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~P:Deepgram.Models.Manage.v1.UsageSummarySchema.Diarize")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.OnPrem.v1.CredentialsSchema")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.OnPrem.v1.CredentialsResponse")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.OnPrem.v1.CredentialResponse")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.PreRecorded.v1.AsyncResponse")]
 [assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.PreRecorded.v1.PrerecordedSchema")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.PreRecorded.v1.SyncPrerecordedResponse")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~P:Deepgram.Models.Shared.v1.TranscriptionSchema.Diarize")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~P:Deepgram.Models.Shared.v1.TranscriptionSchema.DiarizeVersion")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.PreRecorded.v1.SyncResponse")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~P:Deepgram.Models.PreRecorded.v1.TranscriptionSchema.Diarize")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~P:Deepgram.Models.Live.v1.TranscriptionSchema.Diarize")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~P:Deepgram.Models.PreRecorded.v1.TranscriptionSchema.DiarizeVersion")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~P:Deepgram.Models.Live.v1.TranscriptionSchema.DiarizeVersion")]
 [assembly: SuppressMessage("Performance", "SYSLIB1045:Convert to 'GeneratedRegexAttribute'.", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Utilities.UserAgentUtil.GetInfo~System.String")]
 [assembly: SuppressMessage("Performance", "SYSLIB1045:Convert to 'GeneratedRegexAttribute'.", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Extensions.HttpClientExtensions.SetBaseUrl(System.Net.Http.HttpClient,Deepgram.Models.Shared.v1.DeepgramClientOptions)")]
 [assembly: SuppressMessage("Performance", "SYSLIB1045:Convert to 'GeneratedRegexAttribute'.", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.LiveClient.GetBaseUrl(Deepgram.Models.Shared.v1.DeepgramClientOptions)~System.String")]
-[assembly: SuppressMessage("Style", "IDE0057:Use range operator", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Models.PreRecorded.v1.SyncPrerecordedResponse.SecondsToTimestamp(System.Decimal)~System.String")]
+[assembly: SuppressMessage("Style", "IDE0057:Use range operator", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Models.PreRecorded.v1.SyncResponse.SecondsToTimestamp(System.Decimal)~System.String")]
 [assembly: SuppressMessage("Spellchecker", "CRRSP09:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~F:Deepgram.LiveClient._deepgramClientOptions")]
 [assembly: SuppressMessage("Spellchecker", "CRRSP09:A misspelled word has been found", Justification = "<Pending>", Scope = "member", Target = "~M:Deepgram.Extensions.HttpClientExtensions.ConfigureDeepgram(System.Net.Http.HttpClient,System.String,Deepgram.Models.Shared.v1.DeepgramClientOptions)~System.Net.Http.HttpClient")]
 [assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "namespace", Target = "~N:Deepgram")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "namespace", Target = "~N:Deepgram.DeepgramHttpClient")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP09:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.DeepgramHttpClient.DeepgramHttpClientFactory")]
-[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.Shared.v1.DeepgramClientOptions")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "namespace", Target = "~N:Deepgram.HttpClient")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP09:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.HttpClient.HttpClientFactory")]
+[assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.Models.Authenticate.v1.DeepgramClientOptions")]
 [assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.OnPremClient")]
 [assembly: SuppressMessage("Spellchecker", "CRRSP08:A misspelled word has been found", Justification = "<Pending>", Scope = "type", Target = "~T:Deepgram.PrerecordedClient")]
diff --git a/Deepgram/LiveClient.cs b/Deepgram/LiveClient.cs
index 320c44ca..94e23289 100644
--- a/Deepgram/LiveClient.cs
+++ b/Deepgram/LiveClient.cs
@@ -1,6 +1,6 @@
 using Deepgram.Extensions;
 using Deepgram.Models.Live.v1;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram;
 
@@ -29,7 +29,7 @@ public LiveClient(string apiKey, DeepgramClientOptions? deepgramClientOptions =
     /// <summary>
     /// Fires when transcription metadata is received from the Deepgram API
     /// </summary>  
-    public event EventHandler<LiveResponseReceivedEventArgs>? LiveResponseReceived;
+    public event EventHandler<ResponseReceivedEventArgs>? EventResponseReceived;
     #endregion
 
     //TODO when a response is received check if it is a transcript(LiveTranscriptionEvent) or metadata (LiveMetadataEvent) response 
@@ -176,23 +176,23 @@ internal void ProcessDataReceived(WebSocketReceiveResult result, MemoryStream ms
             {
                 try
                 {
-                    var liveResponse = new LiveResponse();
+                    var eventResponse = new EventResponse();
                     var data = JsonDocument.Parse(response);
                     var val = Enum.Parse(typeof(LiveType), data.RootElement.GetProperty("type").GetString()!);
 
                     switch (val)
                     {
                         case LiveType.Results:
-                            liveResponse.Transcription = data.Deserialize<LiveTranscriptionResponse>()!;
+                            eventResponse.Transcription = data.Deserialize<TranscriptionResponse>()!;
                             break;
                         case LiveType.Metadata:
-                            liveResponse.MetaData = data.Deserialize<LiveMetadataResponse>()!;
+                            eventResponse.MetaData = data.Deserialize<MetadataResponse>()!;
                             break;
                         case LiveType.UtteranceEnd:
-                            liveResponse.UtteranceEnd = data.Deserialize<LiveUtteranceEndResponse>()!;
+                            eventResponse.UtteranceEnd = data.Deserialize<UtteranceEndResponse>()!;
                             break;
                     }
-                    LiveResponseReceived?.Invoke(null, new LiveResponseReceivedEventArgs(liveResponse));
+                    EventResponseReceived?.Invoke(null, new ResponseReceivedEventArgs(eventResponse));
                 }
                 catch (Exception ex)
                 {
@@ -283,7 +283,7 @@ private void ProcessException(string action, Exception ex)
             Log.SocketDisposed(logger, action, ex);
         else
             Log.Exception(logger, action, ex);
-        LiveResponseReceived?.Invoke(null, new LiveResponseReceivedEventArgs(new LiveResponse() { Error = ex }));
+        EventResponseReceived?.Invoke(null, new ResponseReceivedEventArgs(new EventResponse() { Error = ex }));
 
     }
 
diff --git a/Deepgram/Logger/Log.cs b/Deepgram/Logger/Log.cs
index b572226c..a653db9b 100644
--- a/Deepgram/Logger/Log.cs
+++ b/Deepgram/Logger/Log.cs
@@ -45,5 +45,5 @@ internal static partial class Log
     EventId = 0018,
     Level = LogLevel.Error,
     Message = "Error creating project key both ExpirationDate and TimeToLiveInSeconds are set: `{createProjectKeySchema}`")]
-    internal static partial void CreateProjectKeyError(this ILogger logger, CreateProjectKeySchema createProjectKeySchema);
+    internal static partial void CreateProjectKeyError(this ILogger logger, KeySchema createProjectKeySchema);
 }
diff --git a/Deepgram/ManageClient.cs b/Deepgram/ManageClient.cs
index 4cbfb9a5..42fa0a9e 100644
--- a/Deepgram/ManageClient.cs
+++ b/Deepgram/ManageClient.cs
@@ -1,6 +1,6 @@
 using Deepgram.Models.Manage;
 using Deepgram.Models.Manage.v1;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram;
 
@@ -16,26 +16,26 @@ public class ManageClient(string apiKey, DeepgramClientOptions? deepgramClientOp
     /// <summary>
     /// Gets projects associated to ApiKey 
     /// </summary>
-    /// <returns><see cref="GetProjectsResponse"/></returns>
-    public async Task<GetProjectsResponse> GetProjects(CancellationToken cancellationToken = default) =>
-        await GetAsync<GetProjectsResponse>(UriSegments.PROJECTS, cancellationToken);
+    /// <returns><see cref="ProjectsResponse"/></returns>
+    public async Task<ProjectsResponse> GetProjects(CancellationToken cancellationToken = default) =>
+        await GetAsync<ProjectsResponse>(UriSegments.PROJECTS, cancellationToken);
 
     /// <summary>
     /// Gets project associated with project Id
     /// </summary>
     /// <param name="projectId">Id of Project</param>
-    /// <returns><see cref="GetProjectResponse"/></returns>
-    public async Task<GetProjectResponse> GetProject(string projectId, CancellationToken cancellationToken = default) =>
-        await GetAsync<GetProjectResponse>($"{UriSegments.PROJECTS}/{projectId}", cancellationToken);
+    /// <returns><see cref="ProjectResponse"/></returns>
+    public async Task<ProjectResponse> GetProject(string projectId, CancellationToken cancellationToken = default) =>
+        await GetAsync<ProjectResponse>($"{UriSegments.PROJECTS}/{projectId}", cancellationToken);
 
     /// <summary>
     /// Update a project associated with the projectID
     /// </summary>
     /// <param name="projectId">ID of project</param>
-    /// <param name="updateProjectSchema"><see cref="UpdateProjectSchema"/> for project</param>
+    /// <param name="updateProjectSchema"><see cref="ProjectSchema"/> for project</param>
     /// <returns><see cref="MessageResponse"/></returns>
     // USES PATCH
-    public async Task<MessageResponse> UpdateProject(string projectId, UpdateProjectSchema updateProjectSchema, CancellationToken cancellationToken = default) =>
+    public async Task<MessageResponse> UpdateProject(string projectId, ProjectSchema updateProjectSchema, CancellationToken cancellationToken = default) =>
         await PatchAsync<MessageResponse>(
             $"{UriSegments.PROJECTS}/{projectId}",
             RequestContentUtil.CreatePayload(updateProjectSchema), cancellationToken);
@@ -64,26 +64,26 @@ public async Task<MessageResponse> LeaveProject(string projectId, CancellationTo
     /// Get the keys associated with the project
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <returns><see cref="GetProjectKeysResponse"/></returns>
-    public async Task<GetProjectKeysResponse> GetProjectKeys(string projectId, CancellationToken cancellationToken = default) =>
-        await GetAsync<GetProjectKeysResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.KEYS}", cancellationToken);
+    /// <returns><see cref="KeysResponse"/></returns>
+    public async Task<KeysResponse> GetProjectKeys(string projectId, CancellationToken cancellationToken = default) =>
+        await GetAsync<KeysResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.KEYS}", cancellationToken);
 
     /// <summary>
     /// Get details of key associated with the key ID
     /// </summary>
     /// <param name="projectId">Id of project</param>
     /// <param name="keyId">Id of key</param>
-    /// <returns><see cref="GetProjectKeyResponse"/></returns>
-    public async Task<GetProjectKeyResponse> GetProjectKey(string projectId, string keyId, CancellationToken cancellationToken = default) =>
-        await GetAsync<GetProjectKeyResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.KEYS}/{keyId}", cancellationToken);
+    /// <returns><see cref="KeyScopeResponse"/></returns>
+    public async Task<KeyScopeResponse> GetProjectKey(string projectId, string keyId, CancellationToken cancellationToken = default) =>
+        await GetAsync<KeyScopeResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.KEYS}/{keyId}", cancellationToken);
 
     /// <summary>
     /// Create a key in the associated project
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <param name="createProjectKeySchema"><see cref="CreateProjectKeySchema"/> for the key to be created</param>
-    /// <returns><see cref="CreateProjectKeyResponse"/></returns>
-    public async Task<CreateProjectKeyResponse> CreateProjectKey(string projectId, CreateProjectKeySchema createProjectKeySchema, CancellationToken cancellationToken = default)
+    /// <param name="createProjectKeySchema"><see cref="KeySchema"/> for the key to be created</param>
+    /// <returns><see cref="KeyResponse"/></returns>
+    public async Task<KeyResponse> CreateProjectKey(string projectId, KeySchema createProjectKeySchema, CancellationToken cancellationToken = default)
     {
         if (createProjectKeySchema.ExpirationDate is not null && createProjectKeySchema.TimeToLiveInSeconds is not null)
         {
@@ -91,7 +91,7 @@ public async Task<CreateProjectKeyResponse> CreateProjectKey(string projectId, C
             throw new ArgumentException("Both ExpirationDate and TimeToLiveInSeconds is set. set either one but not both");
         }
 
-        return await PostAsync<CreateProjectKeyResponse>(
+        return await PostAsync<KeyResponse>(
                      $"{UriSegments.PROJECTS}/{projectId}/keys",
                      RequestContentUtil.CreatePayload(createProjectKeySchema), cancellationToken);
     }
@@ -113,9 +113,9 @@ public async Task DeleteProjectKey(string projectId, string keyId, CancellationT
     /// Get any invites that are associated with project
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <returns><see cref="GetProjectInvitesResponse"/></returns>
-    public async Task<GetProjectInvitesResponse> GetProjectInvites(string projectId, CancellationToken cancellationToken = default) =>
-        await GetAsync<GetProjectInvitesResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.INVITES}", cancellationToken);
+    /// <returns><see cref="InvitesResponse"/></returns>
+    public async Task<InvitesResponse> GetProjectInvites(string projectId, CancellationToken cancellationToken = default) =>
+        await GetAsync<InvitesResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.INVITES}", cancellationToken);
 
     /// <summary>
     /// Delete a project invite that has been sent
@@ -130,12 +130,12 @@ public async Task DeleteProjectInvite(string projectId, string email, Cancellati
     /// Send a invite to the associated project
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <param name="sendProjectInviteSchema"><see cref="SendProjectInviteSchema"/> for a invite to project</param>
+    /// <param name="inviteSchema"><see cref="InviteSchema"/> for a invite to project</param>
     /// <returns><see cref="MessageResponse"/></returns>
-    public async Task<MessageResponse> SendProjectInvite(string projectId, SendProjectInviteSchema sendProjectInviteSchema, CancellationToken cancellationToken = default) =>
+    public async Task<MessageResponse> SendProjectInvite(string projectId, InviteSchema inviteSchema, CancellationToken cancellationToken = default) =>
         await PostAsync<MessageResponse>(
             $"{UriSegments.PROJECTS}/{projectId}/{UriSegments.INVITES}",
-            RequestContentUtil.CreatePayload(sendProjectInviteSchema), cancellationToken);
+            RequestContentUtil.CreatePayload(inviteSchema), cancellationToken);
     #endregion
 
     #region Members
@@ -143,30 +143,30 @@ await PostAsync<MessageResponse>(
     /// Get the members associated with the project
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <returns><see cref="GetProjectMembersResponse"/></returns>
-    public async Task<GetProjectMembersResponse> GetProjectMembers(string projectId, CancellationToken cancellationToken = default) =>
-        await GetAsync<GetProjectMembersResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.MEMBERS}", cancellationToken);
+    /// <returns><see cref="MembersResponse"/></returns>
+    public async Task<MembersResponse> GetProjectMembers(string projectId, CancellationToken cancellationToken = default) =>
+        await GetAsync<MembersResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.MEMBERS}", cancellationToken);
 
     /// <summary>
     /// Get the scopes associated with member
     /// </summary>
     /// <param name="projectId">Id of project</param>
     /// <param name="memberId">Id of member</param>
-    /// <returns><see cref="GetProjectMemberScopesResponse"/></returns>
-    public async Task<GetProjectMemberScopesResponse> GetProjectMemberScopes(string projectId, string memberId, CancellationToken cancellationToken = default) =>
-        await GetAsync<GetProjectMemberScopesResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.MEMBERS}/{memberId}/{UriSegments.SCOPES}", cancellationToken);
+    /// <returns><see cref="MemberScopesResponse"/></returns>
+    public async Task<MemberScopesResponse> GetProjectMemberScopes(string projectId, string memberId, CancellationToken cancellationToken = default) =>
+        await GetAsync<MemberScopesResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.MEMBERS}/{memberId}/{UriSegments.SCOPES}", cancellationToken);
 
     /// <summary>
     /// Update the scopes fot the member
     /// </summary>
     /// <param name="projectId">Id of project</param>
     /// <param name="memberId">Id of member</param>
-    /// <param name="updateProjectMemberScopeSchema">updates scope options for member<see cref="UpdateProjectMemberScopeSchema"/></param>
+    /// <param name="memberScopeSchema">updates scope options for member<see cref="MemberScopeSchema"/></param>
     /// <returns><see cref="MessageResponse"/></returns>  
-    public async Task<MessageResponse> UpdateProjectMemberScope(string projectId, string memberId, UpdateProjectMemberScopeSchema updateProjectMemberScopeSchema, CancellationToken cancellationToken = default) =>
+    public async Task<MessageResponse> UpdateProjectMemberScope(string projectId, string memberId, MemberScopeSchema memberScopeSchema, CancellationToken cancellationToken = default) =>
         await PutAsync<MessageResponse>(
             $"{UriSegments.PROJECTS}/{projectId}/{UriSegments.MEMBERS}/{memberId}/{UriSegments.SCOPES}",
-            RequestContentUtil.CreatePayload(updateProjectMemberScopeSchema), cancellationToken);
+            RequestContentUtil.CreatePayload(memberScopeSchema), cancellationToken);
 
     /// <summary>
     /// Remove member from project, there is no response
@@ -184,12 +184,12 @@ public async Task RemoveProjectMember(string projectId, string memberId, Cancell
     /// Get usage request  associated with the project
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <param name="getProjectUsageRequestsSchema">Project usage request options<see cref="GetProjectUsageRequestsSchema"/>  </param>
-    /// <returns><see cref="GetProjectUsageRequestsResponse"/></returns>
-    public async Task<GetProjectUsageRequestsResponse> GetProjectUsageRequests(string projectId, GetProjectUsageRequestsSchema getProjectUsageRequestsSchema, CancellationToken cancellationToken = default)
+    /// <param name="UsageRequestsSchema">Project usage request options<see cref="UsageRequestsSchema"/>  </param>
+    /// <returns><see cref="UsageRequestsResponse"/></returns>
+    public async Task<UsageRequestsResponse> GetProjectUsageRequests(string projectId, UsageRequestsSchema UsageRequestsSchema, CancellationToken cancellationToken = default)
     {
-        var stringedOptions = QueryParameterUtil.GetParameters(getProjectUsageRequestsSchema);
-        return await GetAsync<GetProjectUsageRequestsResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.REQUESTS}?{stringedOptions}", cancellationToken);
+        var stringedOptions = QueryParameterUtil.GetParameters(UsageRequestsSchema);
+        return await GetAsync<UsageRequestsResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.REQUESTS}?{stringedOptions}", cancellationToken);
     }
 
     /// <summary>
@@ -197,20 +197,20 @@ public async Task<GetProjectUsageRequestsResponse> GetProjectUsageRequests(strin
     /// </summary>
     /// <param name="projectId">Id of project</param>
     /// <param name="requestId">Id of request</param>
-    /// <returns><see cref="GetProjectUsageRequestResponse"/></returns>
-    public async Task<GetProjectUsageRequestResponse> GetProjectUsageRequest(string projectId, string requestId, CancellationToken cancellationToken = default) =>
-        await GetAsync<GetProjectUsageRequestResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.REQUESTS}/{requestId}", cancellationToken);
+    /// <returns><see cref="UsageRequestResponse"/></returns>
+    public async Task<UsageRequestResponse> GetProjectUsageRequest(string projectId, string requestId, CancellationToken cancellationToken = default) =>
+        await GetAsync<UsageRequestResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.REQUESTS}/{requestId}", cancellationToken);
 
     /// <summary>
     /// Gets a summary of usage
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <param name="getProjectUsageSummarySchema">Usage summary options<see cref="GetProjectsUsageSummarySchema"/> </param>
-    /// <returns><see cref="GetProjectUsageSummaryResponse"/></returns>
-    public async Task<GetProjectUsageSummaryResponse> GetProjectUsageSummary(string projectId, GetProjectsUsageSummarySchema getProjectUsageSummarySchema, CancellationToken cancellationToken = default)
+    /// <param name="getProjectUsageSummarySchema">Usage summary options<see cref="UsageSummarySchema"/> </param>
+    /// <returns><see cref="UsageSummaryResponse"/></returns>
+    public async Task<UsageSummaryResponse> GetProjectUsageSummary(string projectId, UsageSummarySchema getProjectUsageSummarySchema, CancellationToken cancellationToken = default)
     {
         var stringedOptions = QueryParameterUtil.GetParameters(getProjectUsageSummarySchema);
-        return await GetAsync<GetProjectUsageSummaryResponse>(
+        return await GetAsync<UsageSummaryResponse>(
             $"{UriSegments.PROJECTS}/{projectId}/{UriSegments.USAGE}?{stringedOptions}", cancellationToken);
     }
 
@@ -218,12 +218,12 @@ public async Task<GetProjectUsageSummaryResponse> GetProjectUsageSummary(string
     /// Get usage fields 
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <param name="getProjectUsageFieldsSchema">Project usage request field options<see cref="GetProjectUsageFieldsSchema"/></param>
-    /// <returns><see cref="GetProjectUsageFieldsResponse"/></returns>
-    public async Task<GetProjectUsageFieldsResponse> GetProjectUsageFields(string projectId, GetProjectUsageFieldsSchema getProjectUsageFieldsSchema, CancellationToken cancellationToken = default)
+    /// <param name="getProjectUsageFieldsSchema">Project usage request field options<see cref="UsageFieldsSchema"/></param>
+    /// <returns><see cref="UsageFieldsResponse"/></returns>
+    public async Task<UsageFieldsResponse> GetProjectUsageFields(string projectId, UsageFieldsSchema getProjectUsageFieldsSchema, CancellationToken cancellationToken = default)
     {
         var stringedOptions = QueryParameterUtil.GetParameters(getProjectUsageFieldsSchema);
-        return await GetAsync<GetProjectUsageFieldsResponse>(
+        return await GetAsync<UsageFieldsResponse>(
             $"{UriSegments.PROJECTS}/{projectId}/{UriSegments.USAGE}/fields?{stringedOptions}", cancellationToken);
     }
     #endregion
@@ -234,17 +234,17 @@ public async Task<GetProjectUsageFieldsResponse> GetProjectUsageFields(string pr
     /// Gets a list of balances
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <returns><see cref="GetProjectBalancesResponse"/></returns>
-    public async Task<GetProjectBalancesResponse> GetProjectBalances(string projectId, CancellationToken cancellationToken = default) =>
-        await GetAsync<GetProjectBalancesResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.BALANCES}", cancellationToken);
+    /// <returns><see cref="BalancesResponse"/></returns>
+    public async Task<BalancesResponse> GetProjectBalances(string projectId, CancellationToken cancellationToken = default) =>
+        await GetAsync<BalancesResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.BALANCES}", cancellationToken);
 
     /// <summary>
     /// Get the balance details associated with the balance id
     /// </summary>
     /// <param name="projectId">Id of project</param>
     /// <param name="balanceId">Id of balance</param>
-    /// <returns><see cref="GetProjectBalanceResponse"/></returns>
-    public async Task<GetProjectBalanceResponse> GetProjectBalance(string projectId, string balanceId, CancellationToken cancellationToken = default) =>
-        await GetAsync<GetProjectBalanceResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.BALANCES}/{balanceId}", cancellationToken);
+    /// <returns><see cref="BalanceResponse"/></returns>
+    public async Task<BalanceResponse> GetProjectBalance(string projectId, string balanceId, CancellationToken cancellationToken = default) =>
+        await GetAsync<BalanceResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.BALANCES}/{balanceId}", cancellationToken);
     #endregion
 }
diff --git a/Deepgram/Models/Shared/v1/DeepgramClientOptions.cs b/Deepgram/Models/Authenticate/v1/DeepgramClientOptions.cs
similarity index 93%
rename from Deepgram/Models/Shared/v1/DeepgramClientOptions.cs
rename to Deepgram/Models/Authenticate/v1/DeepgramClientOptions.cs
index a55d4670..05ddf27c 100644
--- a/Deepgram/Models/Shared/v1/DeepgramClientOptions.cs
+++ b/Deepgram/Models/Authenticate/v1/DeepgramClientOptions.cs
@@ -1,5 +1,5 @@
 
-namespace Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.Authenticate.v1;
 
 /// <summary>
 /// Configuration for the Deepgram client
diff --git a/Deepgram/Models/Shared/v1/Average.cs b/Deepgram/Models/Live/v1/Average.cs
similarity index 83%
rename from Deepgram/Models/Shared/v1/Average.cs
rename to Deepgram/Models/Live/v1/Average.cs
index d281f01a..24080a7a 100644
--- a/Deepgram/Models/Shared/v1/Average.cs
+++ b/Deepgram/Models/Live/v1/Average.cs
@@ -1,4 +1,4 @@
-namespace Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.Live.v1;
 
 public class Average
 {
diff --git a/Deepgram/Models/Live/v1/LiveResponse.cs b/Deepgram/Models/Live/v1/EventResponse.cs
similarity index 69%
rename from Deepgram/Models/Live/v1/LiveResponse.cs
rename to Deepgram/Models/Live/v1/EventResponse.cs
index 7cddd34c..d250a5f0 100644
--- a/Deepgram/Models/Live/v1/LiveResponse.cs
+++ b/Deepgram/Models/Live/v1/EventResponse.cs
@@ -1,18 +1,18 @@
 namespace Deepgram.Models.Live.v1;
-public class LiveResponse
+public class EventResponse
 {
     /// <summary>
     /// MetaData response from the live transcription service
     /// </summary>
-    public LiveMetadataResponse? MetaData { get; set; }
+    public MetadataResponse? MetaData { get; set; }
     /// <summary>
     /// Transcription response from the live transcription service
     /// </summary>
-    public LiveTranscriptionResponse? Transcription { get; set; }
+    public TranscriptionResponse? Transcription { get; set; }
     /// <summary>
     /// UtterancEnd response from the live transcription service
     /// </summary>
-    public LiveUtteranceEndResponse? UtteranceEnd { get; set; }
+    public UtteranceEndResponse? UtteranceEnd { get; set; }
     /// <summary>
     /// Error response from the live transcription service
     /// </summary>
diff --git a/Deepgram/Models/Live/v1/Intent.cs b/Deepgram/Models/Live/v1/Intent.cs
new file mode 100644
index 00000000..00c8c983
--- /dev/null
+++ b/Deepgram/Models/Live/v1/Intent.cs
@@ -0,0 +1,18 @@
+namespace Deepgram.Models.Live.v1;
+
+public record Intent
+{
+    /// <summary>
+    /// <see href="https://developers.deepgram.com/reference/audio-intelligence-apis#intent-recognition"/>
+    /// </summary>
+    [JsonPropertyName("intent")]
+    public string Intention { get; set; }
+    /// <summary>
+    /// <see href="https://developers.deepgram.com/reference/audio-intelligence-apis#intent-recognition"/>
+    /// </summary>
+    [JsonPropertyName("confidence_score")]
+    public double ConfidenceScore { get; set; }
+}
+
+
+
diff --git a/Deepgram/Models/Live/v1/IntentSegment.cs b/Deepgram/Models/Live/v1/IntentSegment.cs
new file mode 100644
index 00000000..c7343fea
--- /dev/null
+++ b/Deepgram/Models/Live/v1/IntentSegment.cs
@@ -0,0 +1,29 @@
+namespace Deepgram.Models.Live.v1;
+
+public record IntentSegment
+{
+    /// <summary>
+    /// <see href="https://developers.deepgram.com/reference/audio-intelligence-apis#intent-recognition"/>
+    /// </summary>
+    [JsonPropertyName("text")]
+    public string Text { get; set; }
+
+    /// <summary>
+    /// <see href="https://developers.deepgram.com/reference/audio-intelligence-apis#intent-recognition"/>
+    /// </summary>
+    [JsonPropertyName("start_word")]
+    public int StartWord { get; set; }
+
+    /// <summary>
+    /// <see href="https://developers.deepgram.com/reference/audio-intelligence-apis#intent-recognition"/>   
+    /// </summary>
+    [JsonPropertyName("end_word")]
+    public int EndWord { get; set; }
+
+    /// <summary>   
+    /// <see href="https://developers.deepgram.com/reference/audio-intelligence-apis#intent-recognition"/>  
+    /// <see cref="Intent"/>
+    /// </summary>
+    [JsonPropertyName("intents")]
+    public IReadOnlyList<Intent> Intents { get; set; }
+}
diff --git a/Deepgram/Models/Live/v1/Intents.cs b/Deepgram/Models/Live/v1/Intents.cs
new file mode 100644
index 00000000..0d5e476a
--- /dev/null
+++ b/Deepgram/Models/Live/v1/Intents.cs
@@ -0,0 +1,11 @@
+namespace Deepgram.Models.Live.v1;
+public record Intents
+{
+    /// <summary> 
+    /// <see href="https://developers.deepgram.com/reference/audio-intelligence-apis#intent-recognition"/>
+    /// <see cref="IntentSegment"/>
+    /// </summary>
+    [JsonPropertyName("segments")]
+    public IReadOnlyList<IntentSegment>? Segments { get; set; }
+
+}
diff --git a/Deepgram/Models/Live/v1/LiveSchema.cs b/Deepgram/Models/Live/v1/LiveSchema.cs
index a73ada81..1b3a6538 100644
--- a/Deepgram/Models/Live/v1/LiveSchema.cs
+++ b/Deepgram/Models/Live/v1/LiveSchema.cs
@@ -1,10 +1,190 @@
-using Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.Live.v1;
 
-namespace Deepgram.Models.Live.v1;
-
-public class LiveSchema : TranscriptionSchema
+public class LiveSchema
 {
 
+    /// <summary>
+    /// Number of transcripts to return per request
+    /// <see href="https://developers.deepgram.com/reference/pre-recorded"/>
+    /// Default is 1
+    /// </summary>
+    [JsonPropertyName("alternatives")]
+    public int? Alternatives { get; set; }
+
+    /// <summary>
+    /// CallBack allows you to have your submitted audio processed asynchronously.
+    /// <see href="https://developers.deepgram.com/docs/callback">
+    /// default is null
+    /// </summary>
+    [JsonPropertyName("callback")]
+    public string? CallBack { get; set; }
+
+    /// <summary>
+    /// Enables callback method
+    /// </summary>
+    [JsonPropertyName("callback_method")]
+    public bool? CallbackMethod { get; set; }
+
+    ///// <summary>
+    ///// Optional. A custom intent you want the model to detect within your input audio if present. Submit up to 100.
+    ///// </summary>
+    //[JsonPropertyName("custom_intent")]
+    //public string CustomIntent { get; set; }
+
+    ///// <summary>
+    ///// Optional. Sets how the model will interpret strings submitted to the custom_intent param. When "strict", the model will only return intents submitted using the custom_intent param. When "extended", the model will return it's own detected intents in addition those submitted using the custom_intents param.
+    ///// </summary>
+    //[JsonPropertyName("custom_intent_mode")]
+    //public string CustomIntentMode { get; set; }
+
+
+    /// <summary>
+    /// Diarize recognizes speaker changes and assigns a speaker to each word in the transcript. 
+    /// <see href="https://developers.deepgram.com/docs/diarization">
+    /// default is false
+    /// </summary>
+    [JsonPropertyName("diarize")]
+    public bool? Diarize { get; set; }
+
+    // <summary>
+    /// <see href="https://developers.deepgram.com/docs/diarization">
+    /// default is null, only applies if Diarize is set to true
+    /// </summary>
+    [JsonPropertyName("diarize_version")]
+    public string? DiarizeVersion { get; set; }
+
+    /// <summary>
+    /// Deepgram’s Extra Metadata feature allows you to attach arbitrary key-value pairs to your API requests that are attached to the API response for usage in downstream processing.
+    /// Extra metadata is limited to 2048 characters per key-value pair.
+    /// <see href="https://developers.deepgram.com/docs/extra-metadata"/>
+    /// </summary>
+    [JsonPropertyName("extra")]
+    public Dictionary<string, string> Extra { get; set; }
+
+
+    /// <summary>
+    /// Whether to include words like "uh" and "um" in transcription output. 
+    ///<see href="https://developers.deepgram.com/reference/pre-recorded"/>
+    /// </summary>
+    [JsonPropertyName("filler_words")]
+    public bool? FillerWords { get; set; }
+
+    ///// <summary>
+    ///// Enables intent recognition
+    ///// </summary>
+    //[JsonPropertyName("intents")]
+    //public bool? Intents { get; set; }
+
+    /// <summary>
+    /// Keywords can boost or suppress specialized terminology.
+    /// <see href="https://developers.deepgram.com/docs/keywords">
+    /// </summary>
+    [JsonPropertyName("keywords")]
+    public List<string>? Keywords { get; set; }
+
+    /// <summary>
+    /// Primary spoken language of submitted audio 
+    /// <see href="https://developers.deepgram.com/docs/language">
+    /// default value is 'en' 
+    /// </summary>
+    [JsonPropertyName("language")]
+    public string? Language { get; set; }
+
+    /// <summary>
+    /// AI model used to process submitted audio
+    /// <see href="https://developers.deepgram.com/docs/model">
+    /// </summary>
+    [JsonPropertyName("model")]
+    public string? Model { get; set; }
+
+    /// <summary>
+    /// Multichannel transcribes each channel in submitted audio independently. 
+    /// <see href="https://developers.deepgram.com/docs/multichannel">
+    /// </summary>
+    [JsonPropertyName("multichannel")]
+    public bool? MultiChannel { get; set; }
+
+
+    /// <summary>
+    /// Profanity Filter looks for recognized profanity and converts it to the nearest recognized 
+    /// non-profane word or removes it from the transcript completely.
+    /// <see href="https://developers.deepgram.com/docs/profanity-filter">
+    /// for use with base model tier only
+    /// </summary>
+    [JsonPropertyName("profanity_filter")]
+    public bool? ProfanityFilter { get; set; }
+
+    /// <summary>
+    /// Adds punctuation and capitalization to transcript
+    /// <see href="https://developers.deepgram.com/docs/punctuation">
+    /// </summary>
+    [JsonPropertyName("punctuate")]
+    public bool? Punctuate { get; set; }
+
+    /// <summary>
+    ///  Indicates whether to redact sensitive information, replacing redacted content with asterisks (*). Can send multiple instances in query string (for example, redact=pci&redact=numbers).
+    ///  <see href="https://developers.deepgram.com/docs/redaction">
+    ///  default is List<string>("false") 
+    /// </summary>
+    [JsonPropertyName("redact")]
+    public List<string>? Redact { get; set; }
+
+    /// <summary>
+    /// Find and Replace searches for terms or phrases in submitted audio and replaces them.
+    /// <see href="https://developers.deepgram.com/docs/find-and-replace">
+    /// default is null
+    /// </summary>
+    [JsonPropertyName("replace")]
+    public List<string>? Replace { get; set; }
+
+    /// <summary>
+    /// Search searches for terms or phrases in submitted audio. 
+    /// <see href="https://developers.deepgram.com/docs/search">
+    /// default is null
+    /// </summary>
+    [JsonPropertyName("search")]
+    public List<string>? Search { get; set; }
+
+    ///// <summary>
+    ///// Enables sentiment analysis false by default
+    ///// </summary>
+    //[JsonPropertyName("sentiment")]
+    //public bool? Sentiment { get; set; }
+
+    //[JsonPropertyName("sentiment_threshold")]
+    //public double? SentimentThreshold { get; set; }
+
+    /// <summary>
+    /// Smart Format formats transcripts to improve readability. 
+    /// <see href="https://developers.deepgram.com/docs/smart-format">
+    /// </summary>
+    [JsonPropertyName("smart_format")]
+    public bool? SmartFormat { get; set; }
+
+    /// <summary>
+    /// Tagging allows you to label your requests with one or more tags in a list,for the purpose of identification during usage reporting.
+    /// <see href="https://developers.deepgram.com/docs/tagging">
+    /// Default is a null 
+    /// </summary>
+    [JsonPropertyName("tag")]
+    public List<string>? Tag { get; set; }
+
+    ///// <summary>
+    /////  Level of model you would like to use in your request.
+    /////  <see href="https://developers.deepgram.com/docs/model">   
+    ///// </summary>
+    //[JsonPropertyName("tier")]
+    //[Obsolete("Use Model with joint model syntax https://developers.deepgram.com/docs/models-languages-overview")]
+    //public string? Tier { get; set; }
+
+    /// <summary>
+    /// Version of the model to use.
+    /// <see href="https://developers.deepgram.com/docs/version">
+    /// default value is "latest"
+    /// </summary>
+    [JsonPropertyName("version")]
+    public string? Version { get; set; }
+
     /// <summary>
     /// Channels allows you to specify the number of independent audio channels your submitted audio contains. 
     /// Used when the Encoding feature is also being used to submit streaming raw audio
diff --git a/Deepgram/Models/Live/v1/LiveMetadataResponse.cs b/Deepgram/Models/Live/v1/MetadataResponse.cs
similarity index 88%
rename from Deepgram/Models/Live/v1/LiveMetadataResponse.cs
rename to Deepgram/Models/Live/v1/MetadataResponse.cs
index 98a200df..da60e79f 100644
--- a/Deepgram/Models/Live/v1/LiveMetadataResponse.cs
+++ b/Deepgram/Models/Live/v1/MetadataResponse.cs
@@ -1,8 +1,6 @@
-using Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.Live.v1;
 
-namespace Deepgram.Models.Live.v1;
-
-public record LiveMetadataResponse
+public record MetadataResponse
 {
     [JsonPropertyName("type")]
     [JsonConverter(typeof(JsonStringEnumConverter))]
diff --git a/Deepgram/Models/Shared/v1/ModelInfo.cs b/Deepgram/Models/Live/v1/ModelInfo.cs
similarity index 85%
rename from Deepgram/Models/Shared/v1/ModelInfo.cs
rename to Deepgram/Models/Live/v1/ModelInfo.cs
index 08c03acd..4dfb2acc 100644
--- a/Deepgram/Models/Shared/v1/ModelInfo.cs
+++ b/Deepgram/Models/Live/v1/ModelInfo.cs
@@ -1,4 +1,4 @@
-namespace Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.Live.v1;
 
 public record ModelInfo
 {
diff --git a/Deepgram/Models/Shared/v1/Segment.cs b/Deepgram/Models/Live/v1/Segment.cs
similarity index 91%
rename from Deepgram/Models/Shared/v1/Segment.cs
rename to Deepgram/Models/Live/v1/Segment.cs
index fc44a3b5..a189d668 100644
--- a/Deepgram/Models/Shared/v1/Segment.cs
+++ b/Deepgram/Models/Live/v1/Segment.cs
@@ -1,4 +1,4 @@
-namespace Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.Live.v1;
 
 public class Segment
 {
diff --git a/Deepgram/Models/Shared/v1/SentimentGroup.cs b/Deepgram/Models/Live/v1/SentimentGroup.cs
similarity index 92%
rename from Deepgram/Models/Shared/v1/SentimentGroup.cs
rename to Deepgram/Models/Live/v1/SentimentGroup.cs
index ffe51f7b..4b4e69e9 100644
--- a/Deepgram/Models/Shared/v1/SentimentGroup.cs
+++ b/Deepgram/Models/Live/v1/SentimentGroup.cs
@@ -1,5 +1,4 @@
-
-namespace Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.Live.v1;
 
 public class SentimentGroup
 {
diff --git a/Deepgram/Models/Shared/v1/SentimentInfo.cs b/Deepgram/Models/Live/v1/SentimentInfo.cs
similarity index 87%
rename from Deepgram/Models/Shared/v1/SentimentInfo.cs
rename to Deepgram/Models/Live/v1/SentimentInfo.cs
index 08aa3449..e4416389 100644
--- a/Deepgram/Models/Shared/v1/SentimentInfo.cs
+++ b/Deepgram/Models/Live/v1/SentimentInfo.cs
@@ -1,4 +1,4 @@
-namespace Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.Live.v1;
 
 public class SentimentInfo
 {
diff --git a/Deepgram/Models/Shared/v1/SentimentSegment.cs b/Deepgram/Models/Live/v1/SentimentSegment.cs
similarity index 91%
rename from Deepgram/Models/Shared/v1/SentimentSegment.cs
rename to Deepgram/Models/Live/v1/SentimentSegment.cs
index b8c03905..fa6621ff 100644
--- a/Deepgram/Models/Shared/v1/SentimentSegment.cs
+++ b/Deepgram/Models/Live/v1/SentimentSegment.cs
@@ -1,4 +1,4 @@
-namespace Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.Live.v1;
 
 public class SentimentSegment
 {
diff --git a/Deepgram/Models/Shared/v1/Sentiments.cs b/Deepgram/Models/Live/v1/Sentiments.cs
similarity index 92%
rename from Deepgram/Models/Shared/v1/Sentiments.cs
rename to Deepgram/Models/Live/v1/Sentiments.cs
index b6f8a1bb..48b31764 100644
--- a/Deepgram/Models/Shared/v1/Sentiments.cs
+++ b/Deepgram/Models/Live/v1/Sentiments.cs
@@ -1,5 +1,4 @@
-
-namespace Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.Live.v1;
 
 public record Sentiments
 {
diff --git a/Deepgram/Models/Live/v1/LiveTranscriptionResponse.cs b/Deepgram/Models/Live/v1/TranscriptionResponse.cs
similarity index 88%
rename from Deepgram/Models/Live/v1/LiveTranscriptionResponse.cs
rename to Deepgram/Models/Live/v1/TranscriptionResponse.cs
index 27cf1352..15a61951 100644
--- a/Deepgram/Models/Live/v1/LiveTranscriptionResponse.cs
+++ b/Deepgram/Models/Live/v1/TranscriptionResponse.cs
@@ -1,7 +1,5 @@
-using Deepgram.Models.PreRecorded.v1;
-
-namespace Deepgram.Models.Live.v1;
-public record LiveTranscriptionResponse
+namespace Deepgram.Models.Live.v1;
+public record TranscriptionResponse
 {
     [JsonPropertyName("type")]
     [JsonConverter(typeof(JsonStringEnumConverter))]
diff --git a/Deepgram/Models/Live/v1/LiveUtteranceEndResponse.cs b/Deepgram/Models/Live/v1/UtteranceEndResponse.cs
similarity index 90%
rename from Deepgram/Models/Live/v1/LiveUtteranceEndResponse.cs
rename to Deepgram/Models/Live/v1/UtteranceEndResponse.cs
index eeda0d24..5707e3f8 100644
--- a/Deepgram/Models/Live/v1/LiveUtteranceEndResponse.cs
+++ b/Deepgram/Models/Live/v1/UtteranceEndResponse.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Live.v1;
-public class LiveUtteranceEndResponse
+public class UtteranceEndResponse
 {
     [JsonPropertyName("type")]
     [JsonConverter(typeof(JsonStringEnumConverter))]
diff --git a/Deepgram/Models/Manage/v1/GetProjectBalanceResponse.cs b/Deepgram/Models/Manage/v1/BalanceResponse.cs
similarity index 94%
rename from Deepgram/Models/Manage/v1/GetProjectBalanceResponse.cs
rename to Deepgram/Models/Manage/v1/BalanceResponse.cs
index 979b3f20..6d64a052 100644
--- a/Deepgram/Models/Manage/v1/GetProjectBalanceResponse.cs
+++ b/Deepgram/Models/Manage/v1/BalanceResponse.cs
@@ -1,6 +1,6 @@
 namespace Deepgram.Models.Manage.v1;
 
-public record GetProjectBalanceResponse
+public record BalanceResponse
 {
     /// <summary>
     /// Balance id
diff --git a/Deepgram/Models/Manage/v1/BalancesResponse.cs b/Deepgram/Models/Manage/v1/BalancesResponse.cs
new file mode 100644
index 00000000..fc151837
--- /dev/null
+++ b/Deepgram/Models/Manage/v1/BalancesResponse.cs
@@ -0,0 +1,10 @@
+namespace Deepgram.Models.Manage.v1;
+
+public record BalancesResponse
+{
+    /// <summary>
+    /// ReadOnlyList of project balances <see cref="BalanceResponse"/>
+    /// </summary>
+    [JsonPropertyName("balances")]
+    public IReadOnlyList<BalanceResponse>? Balances { get; set; }
+}
diff --git a/Deepgram/Models/Manage/v1/GetProjectBalancesResponse.cs b/Deepgram/Models/Manage/v1/GetProjectBalancesResponse.cs
deleted file mode 100644
index 92e38fcc..00000000
--- a/Deepgram/Models/Manage/v1/GetProjectBalancesResponse.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-namespace Deepgram.Models.Manage.v1;
-
-public record GetProjectBalancesResponse
-{
-    /// <summary>
-    /// ReadOnlyList of project balances <see cref="GetProjectBalanceResponse"/>
-    /// </summary>
-    [JsonPropertyName("balances")]
-    public IReadOnlyList<GetProjectBalanceResponse>? Balances { get; set; }
-}
diff --git a/Deepgram/Models/Manage/v1/SendProjectInviteSchema.cs b/Deepgram/Models/Manage/v1/InviteSchema.cs
similarity index 84%
rename from Deepgram/Models/Manage/v1/SendProjectInviteSchema.cs
rename to Deepgram/Models/Manage/v1/InviteSchema.cs
index 50b0deb4..c1e018cf 100644
--- a/Deepgram/Models/Manage/v1/SendProjectInviteSchema.cs
+++ b/Deepgram/Models/Manage/v1/InviteSchema.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public class SendProjectInviteSchema(string email, string scope)
+public class InviteSchema(string email, string scope)
 {
     /// <summary>
     /// email of the person being invited
diff --git a/Deepgram/Models/Manage/v1/GetProjectInvitesResponse.cs b/Deepgram/Models/Manage/v1/InvitesResponse.cs
similarity index 85%
rename from Deepgram/Models/Manage/v1/GetProjectInvitesResponse.cs
rename to Deepgram/Models/Manage/v1/InvitesResponse.cs
index 56e6da46..e57c1f21 100644
--- a/Deepgram/Models/Manage/v1/GetProjectInvitesResponse.cs
+++ b/Deepgram/Models/Manage/v1/InvitesResponse.cs
@@ -1,6 +1,6 @@
 namespace Deepgram.Models.Manage.v1;
 
-public record GetProjectInvitesResponse
+public record InvitesResponse
 {
     /// <summary>
     /// ReadOnlyList of project invites <see cref="Invite"/>
diff --git a/Deepgram/Models/Manage/v1/CreateProjectKeyResponse.cs b/Deepgram/Models/Manage/v1/KeyResponse.cs
similarity index 94%
rename from Deepgram/Models/Manage/v1/CreateProjectKeyResponse.cs
rename to Deepgram/Models/Manage/v1/KeyResponse.cs
index e7644a9f..4368416d 100644
--- a/Deepgram/Models/Manage/v1/CreateProjectKeyResponse.cs
+++ b/Deepgram/Models/Manage/v1/KeyResponse.cs
@@ -1,6 +1,6 @@
 namespace Deepgram.Models.Manage.v1;
 
-public record CreateProjectKeyResponse
+public record KeyResponse
 {
     /// <summary>
     /// Unique identifier of the Deepgram API key
diff --git a/Deepgram/Models/Manage/v1/CreateProjectKeySchema.cs b/Deepgram/Models/Manage/v1/KeySchema.cs
similarity index 92%
rename from Deepgram/Models/Manage/v1/CreateProjectKeySchema.cs
rename to Deepgram/Models/Manage/v1/KeySchema.cs
index 9017c299..3c57e2bf 100644
--- a/Deepgram/Models/Manage/v1/CreateProjectKeySchema.cs
+++ b/Deepgram/Models/Manage/v1/KeySchema.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage;
-public class CreateProjectKeySchema(string comment, List<string> scopes)
+public class KeySchema(string comment, List<string> scopes)
 {
 
     /// <summary>
diff --git a/Deepgram/Models/Manage/v1/GetProjectKeyResponse.cs b/Deepgram/Models/Manage/v1/KeyScopeResponse.cs
similarity index 90%
rename from Deepgram/Models/Manage/v1/GetProjectKeyResponse.cs
rename to Deepgram/Models/Manage/v1/KeyScopeResponse.cs
index 5d5baa1a..8eb1d0fd 100644
--- a/Deepgram/Models/Manage/v1/GetProjectKeyResponse.cs
+++ b/Deepgram/Models/Manage/v1/KeyScopeResponse.cs
@@ -1,6 +1,6 @@
 namespace Deepgram.Models.Manage.v1;
 
-public record GetProjectKeyResponse
+public record KeyScopeResponse
 {
     /// <summary>
     /// member object <see cref="v1.Member"/>
diff --git a/Deepgram/Models/Manage/v1/GetProjectKeysResponse.cs b/Deepgram/Models/Manage/v1/KeysResponse.cs
similarity index 58%
rename from Deepgram/Models/Manage/v1/GetProjectKeysResponse.cs
rename to Deepgram/Models/Manage/v1/KeysResponse.cs
index e7908386..0d94976e 100644
--- a/Deepgram/Models/Manage/v1/GetProjectKeysResponse.cs
+++ b/Deepgram/Models/Manage/v1/KeysResponse.cs
@@ -1,9 +1,9 @@
 namespace Deepgram.Models.Manage.v1;
-public record GetProjectKeysResponse
+public record KeysResponse
 {
     /// <summary>
     /// List of Deepgram api keys
     /// </summary>
     [JsonPropertyName("api_keys")]
-    public IReadOnlyList<GetProjectKeyResponse>? ApiKeys { get; set; }
+    public IReadOnlyList<KeyScopeResponse>? ApiKeys { get; set; }
 }
diff --git a/Deepgram/Models/Manage/v1/UpdateProjectMemberScopeSchema.cs b/Deepgram/Models/Manage/v1/MemberScopeSchema.cs
similarity index 76%
rename from Deepgram/Models/Manage/v1/UpdateProjectMemberScopeSchema.cs
rename to Deepgram/Models/Manage/v1/MemberScopeSchema.cs
index 1f3a1701..f231ee18 100644
--- a/Deepgram/Models/Manage/v1/UpdateProjectMemberScopeSchema.cs
+++ b/Deepgram/Models/Manage/v1/MemberScopeSchema.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public class UpdateProjectMemberScopeSchema(string scope)
+public class MemberScopeSchema(string scope)
 {
     /// <summary>
     /// Scope to add for member
diff --git a/Deepgram/Models/Manage/v1/GetProjectMemberScopesResponse.cs b/Deepgram/Models/Manage/v1/MemberScopesResponse.cs
similarity index 82%
rename from Deepgram/Models/Manage/v1/GetProjectMemberScopesResponse.cs
rename to Deepgram/Models/Manage/v1/MemberScopesResponse.cs
index d5356b1b..d55b27e3 100644
--- a/Deepgram/Models/Manage/v1/GetProjectMemberScopesResponse.cs
+++ b/Deepgram/Models/Manage/v1/MemberScopesResponse.cs
@@ -1,6 +1,6 @@
 namespace Deepgram.Models.Manage.v1;
 
-public record GetProjectMemberScopesResponse
+public record MemberScopesResponse
 {
     /// <summary>
     /// Project scopes associated with member
diff --git a/Deepgram/Models/Manage/v1/GetProjectMembersResponse.cs b/Deepgram/Models/Manage/v1/MembersResponse.cs
similarity index 77%
rename from Deepgram/Models/Manage/v1/GetProjectMembersResponse.cs
rename to Deepgram/Models/Manage/v1/MembersResponse.cs
index 87c78b70..da005cb5 100644
--- a/Deepgram/Models/Manage/v1/GetProjectMembersResponse.cs
+++ b/Deepgram/Models/Manage/v1/MembersResponse.cs
@@ -1,6 +1,6 @@
 namespace Deepgram.Models.Manage.v1;
 
-public record GetProjectMembersResponse
+public record MembersResponse
 {
     [JsonPropertyName("members")]
     public IReadOnlyList<Member>? Members { get; set; }
diff --git a/Deepgram/Models/Manage/v1/GetProjectResponse.cs b/Deepgram/Models/Manage/v1/ProjectResponse.cs
similarity index 94%
rename from Deepgram/Models/Manage/v1/GetProjectResponse.cs
rename to Deepgram/Models/Manage/v1/ProjectResponse.cs
index 43c34caa..aa91115e 100644
--- a/Deepgram/Models/Manage/v1/GetProjectResponse.cs
+++ b/Deepgram/Models/Manage/v1/ProjectResponse.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public record GetProjectResponse
+public record ProjectResponse
 {
     /// <summary>
     /// Unique identifier of the Deepgram project
diff --git a/Deepgram/Models/Manage/v1/UpdateProjectSchema.cs b/Deepgram/Models/Manage/v1/ProjectSchema.cs
similarity index 90%
rename from Deepgram/Models/Manage/v1/UpdateProjectSchema.cs
rename to Deepgram/Models/Manage/v1/ProjectSchema.cs
index cd94c8b6..7b6da5f9 100644
--- a/Deepgram/Models/Manage/v1/UpdateProjectSchema.cs
+++ b/Deepgram/Models/Manage/v1/ProjectSchema.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public class UpdateProjectSchema
+public class ProjectSchema
 {
     /// <summary>
     /// Name of Project
diff --git a/Deepgram/Models/Manage/v1/GetProjectsResponse.cs b/Deepgram/Models/Manage/v1/ProjectsResponse.cs
similarity index 80%
rename from Deepgram/Models/Manage/v1/GetProjectsResponse.cs
rename to Deepgram/Models/Manage/v1/ProjectsResponse.cs
index c976cdac..00cb7669 100644
--- a/Deepgram/Models/Manage/v1/GetProjectsResponse.cs
+++ b/Deepgram/Models/Manage/v1/ProjectsResponse.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public record GetProjectsResponse
+public record ProjectsResponse
 {
     [JsonPropertyName("projects")]
     public IReadOnlyList<Project>? Projects { get; set; }
diff --git a/Deepgram/Models/Manage/v1/GetProjectUsageFieldsResponse.cs b/Deepgram/Models/Manage/v1/UsageFieldsResponse.cs
similarity index 95%
rename from Deepgram/Models/Manage/v1/GetProjectUsageFieldsResponse.cs
rename to Deepgram/Models/Manage/v1/UsageFieldsResponse.cs
index 5876d2f2..c34a4bc6 100644
--- a/Deepgram/Models/Manage/v1/GetProjectUsageFieldsResponse.cs
+++ b/Deepgram/Models/Manage/v1/UsageFieldsResponse.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public record GetProjectUsageFieldsResponse
+public record UsageFieldsResponse
 {
     /// <summary>
     /// ReadOnlyList of included tags.
diff --git a/Deepgram/Models/Manage/v1/GetProjectUsageFieldsSchema.cs b/Deepgram/Models/Manage/v1/UsageFieldsSchema.cs
similarity index 93%
rename from Deepgram/Models/Manage/v1/GetProjectUsageFieldsSchema.cs
rename to Deepgram/Models/Manage/v1/UsageFieldsSchema.cs
index 328c1146..849b259b 100644
--- a/Deepgram/Models/Manage/v1/GetProjectUsageFieldsSchema.cs
+++ b/Deepgram/Models/Manage/v1/UsageFieldsSchema.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public class GetProjectUsageFieldsSchema
+public class UsageFieldsSchema
 {
     /// <summary>
     /// Start date of the requested date range. Format is YYYY-MM-DD. If a full timestamp is given, it will be truncated to a day. Dates are UTC. Defaults to the date of your first request.
diff --git a/Deepgram/Models/Manage/v1/GetProjectUsageRequestResponse.cs b/Deepgram/Models/Manage/v1/UsageRequestResponse.cs
similarity index 96%
rename from Deepgram/Models/Manage/v1/GetProjectUsageRequestResponse.cs
rename to Deepgram/Models/Manage/v1/UsageRequestResponse.cs
index 0208d89f..7b33da70 100644
--- a/Deepgram/Models/Manage/v1/GetProjectUsageRequestResponse.cs
+++ b/Deepgram/Models/Manage/v1/UsageRequestResponse.cs
@@ -1,6 +1,6 @@
 namespace Deepgram.Models.Manage.v1;
 
-public record GetProjectUsageRequestResponse
+public record UsageRequestResponse
 {
     /// <summary>
     /// Identifier of request.
diff --git a/Deepgram/Models/Manage/v1/GetProjectsUsageRequestsResponse.cs b/Deepgram/Models/Manage/v1/UsageRequestsResponse.cs
similarity index 62%
rename from Deepgram/Models/Manage/v1/GetProjectsUsageRequestsResponse.cs
rename to Deepgram/Models/Manage/v1/UsageRequestsResponse.cs
index 9983cb38..a06f23e9 100644
--- a/Deepgram/Models/Manage/v1/GetProjectsUsageRequestsResponse.cs
+++ b/Deepgram/Models/Manage/v1/UsageRequestsResponse.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public record GetProjectUsageRequestsResponse
+public record UsageRequestsResponse
 {
     [JsonPropertyName("page")]
     public int? Page { get; set; }
@@ -8,5 +8,5 @@ public record GetProjectUsageRequestsResponse
     public int? Limit { get; set; }
 
     [JsonPropertyName("requests")]
-    public IReadOnlyList<GetProjectUsageRequestResponse>? Requests { get; set; }
+    public IReadOnlyList<UsageRequestResponse>? Requests { get; set; }
 }
diff --git a/Deepgram/Models/Manage/v1/GetProjectsUsageRequestsSchema.cs b/Deepgram/Models/Manage/v1/UsageRequestsSchema.cs
similarity index 96%
rename from Deepgram/Models/Manage/v1/GetProjectsUsageRequestsSchema.cs
rename to Deepgram/Models/Manage/v1/UsageRequestsSchema.cs
index dba7d15d..5dd13af1 100644
--- a/Deepgram/Models/Manage/v1/GetProjectsUsageRequestsSchema.cs
+++ b/Deepgram/Models/Manage/v1/UsageRequestsSchema.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public class GetProjectUsageRequestsSchema
+public class UsageRequestsSchema
 {
     // <summary>
     /// Start date of the requested date range. Formats accepted are YYYY-MM-DD, YYYY-MM-DDTHH:MM:SS, or YYYY-MM-DDTHH:MM:SS+HH:MM.
diff --git a/Deepgram/Models/Manage/v1/GetProjectsUsageSummaryResponse.cs b/Deepgram/Models/Manage/v1/UsageSummaryResponse.cs
similarity index 94%
rename from Deepgram/Models/Manage/v1/GetProjectsUsageSummaryResponse.cs
rename to Deepgram/Models/Manage/v1/UsageSummaryResponse.cs
index 1d76e014..f85a76e4 100644
--- a/Deepgram/Models/Manage/v1/GetProjectsUsageSummaryResponse.cs
+++ b/Deepgram/Models/Manage/v1/UsageSummaryResponse.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public record GetProjectUsageSummaryResponse
+public record UsageSummaryResponse
 {
     /// <summary>
     /// Start date for included requests.
diff --git a/Deepgram/Models/Manage/v1/GetProjectsUsageSummarySchema.cs b/Deepgram/Models/Manage/v1/UsageSummarySchema.cs
similarity index 99%
rename from Deepgram/Models/Manage/v1/GetProjectsUsageSummarySchema.cs
rename to Deepgram/Models/Manage/v1/UsageSummarySchema.cs
index 6606a37f..83c3b127 100644
--- a/Deepgram/Models/Manage/v1/GetProjectsUsageSummarySchema.cs
+++ b/Deepgram/Models/Manage/v1/UsageSummarySchema.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.Manage.v1;
-public class GetProjectsUsageSummarySchema
+public class UsageSummarySchema
 {
     /// <summary>
     /// List of Accessors, Limits results to the given API key(s)
diff --git a/Deepgram/Models/OnPrem/v1/OnPremCredentialsResponse.cs b/Deepgram/Models/OnPrem/v1/CredentialResponse.cs
similarity index 85%
rename from Deepgram/Models/OnPrem/v1/OnPremCredentialsResponse.cs
rename to Deepgram/Models/OnPrem/v1/CredentialResponse.cs
index b113209c..c8b99b82 100644
--- a/Deepgram/Models/OnPrem/v1/OnPremCredentialsResponse.cs
+++ b/Deepgram/Models/OnPrem/v1/CredentialResponse.cs
@@ -1,6 +1,6 @@
 namespace Deepgram.Models.OnPrem.v1;
 
-public record OnPremCredentialsResponse
+public record CredentialResponse
 
 {
     [JsonPropertyName("member")]
diff --git a/Deepgram/Models/OnPrem/v1/CredentialsResponse.cs b/Deepgram/Models/OnPrem/v1/CredentialsResponse.cs
new file mode 100644
index 00000000..97f9bd3d
--- /dev/null
+++ b/Deepgram/Models/OnPrem/v1/CredentialsResponse.cs
@@ -0,0 +1,6 @@
+namespace Deepgram.Models.OnPrem.v1;
+public record CredentialsResponse
+{
+    [JsonPropertyName("distribution_credentials")]
+    public IReadOnlyList<CredentialResponse> DistributionCredentials { get; set; }
+}
diff --git a/Deepgram/Models/OnPrem/v1/CreateOnPremCredentialsSchema.cs b/Deepgram/Models/OnPrem/v1/CredentialsSchema.cs
similarity index 91%
rename from Deepgram/Models/OnPrem/v1/CreateOnPremCredentialsSchema.cs
rename to Deepgram/Models/OnPrem/v1/CredentialsSchema.cs
index 635c519b..b53b02a8 100644
--- a/Deepgram/Models/OnPrem/v1/CreateOnPremCredentialsSchema.cs
+++ b/Deepgram/Models/OnPrem/v1/CredentialsSchema.cs
@@ -1,6 +1,6 @@
 namespace Deepgram.Models.OnPrem.v1;
 
-public class CreateOnPremCredentialsSchema
+public class CredentialsSchema
 {
     /// <summary>
     /// comment to credentials
diff --git a/Deepgram/Models/OnPrem/v1/ListOnPremCredentialsResponse.cs b/Deepgram/Models/OnPrem/v1/ListOnPremCredentialsResponse.cs
deleted file mode 100644
index 4b7e30cf..00000000
--- a/Deepgram/Models/OnPrem/v1/ListOnPremCredentialsResponse.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-namespace Deepgram.Models.OnPrem.v1;
-public record ListOnPremCredentialsResponse
-{
-    [JsonPropertyName("distribution_credentials")]
-    public IReadOnlyList<OnPremCredentialsResponse> DistributionCredentials { get; set; }
-}
diff --git a/Deepgram/Models/PreRecorded/v1/Alternative.cs b/Deepgram/Models/PreRecorded/v1/Alternative.cs
index 44f4cfd1..e5b5b1c9 100644
--- a/Deepgram/Models/PreRecorded/v1/Alternative.cs
+++ b/Deepgram/Models/PreRecorded/v1/Alternative.cs
@@ -1,6 +1,4 @@
-using Deepgram.Models.Shared.v1;
-
-namespace Deepgram.Models.PreRecorded.v1;
+namespace Deepgram.Models.PreRecorded.v1;
 
 public record Alternative
 {
diff --git a/Deepgram/Models/PreRecorded/v1/AsyncPrerecordedResponse.cs b/Deepgram/Models/PreRecorded/v1/AsyncResponse.cs
similarity index 87%
rename from Deepgram/Models/PreRecorded/v1/AsyncPrerecordedResponse.cs
rename to Deepgram/Models/PreRecorded/v1/AsyncResponse.cs
index 7f1ec89c..69e9ec0f 100644
--- a/Deepgram/Models/PreRecorded/v1/AsyncPrerecordedResponse.cs
+++ b/Deepgram/Models/PreRecorded/v1/AsyncResponse.cs
@@ -1,5 +1,5 @@
 namespace Deepgram.Models.PreRecorded.v1;
-public record AsyncPrerecordedResponse
+public record AsyncResponse
 {
     /// <summary>
     /// Id of transcription request returned when
diff --git a/Deepgram/Models/PreRecorded/v1/Average.cs b/Deepgram/Models/PreRecorded/v1/Average.cs
new file mode 100644
index 00000000..3cbc0768
--- /dev/null
+++ b/Deepgram/Models/PreRecorded/v1/Average.cs
@@ -0,0 +1,10 @@
+namespace Deepgram.Models.PreRecorded.v1;
+
+public class Average
+{
+    [JsonPropertyName("sentiment")]
+    public string? Sentiment { get; set; }
+
+    [JsonPropertyName("sentiment_score")]
+    public double? SentimentScore { get; set; }
+}
diff --git a/Deepgram/Models/PreRecorded/v1/Metadata.cs b/Deepgram/Models/PreRecorded/v1/Metadata.cs
index 4a23bd94..f3216ffe 100644
--- a/Deepgram/Models/PreRecorded/v1/Metadata.cs
+++ b/Deepgram/Models/PreRecorded/v1/Metadata.cs
@@ -1,6 +1,4 @@
-using Deepgram.Models.Shared.v1;
-
-namespace Deepgram.Models.PreRecorded.v1;
+namespace Deepgram.Models.PreRecorded.v1;
 public record Metadata
 {
 
diff --git a/Deepgram/Models/PreRecorded/v1/ModelInfo.cs b/Deepgram/Models/PreRecorded/v1/ModelInfo.cs
new file mode 100644
index 00000000..1f58505e
--- /dev/null
+++ b/Deepgram/Models/PreRecorded/v1/ModelInfo.cs
@@ -0,0 +1,13 @@
+namespace Deepgram.Models.PreRecorded.v1;
+
+public record ModelInfo
+{
+    [JsonPropertyName("name")]
+    public string? Name { get; set; }
+
+    [JsonPropertyName("version")]
+    public string? Version { get; set; }
+
+    [JsonPropertyName("arch")]
+    public string? Arch { get; set; }
+}
diff --git a/Deepgram/Models/PreRecorded/v1/Paragraph.cs b/Deepgram/Models/PreRecorded/v1/Paragraph.cs
index cda3e3b4..f827baf1 100644
--- a/Deepgram/Models/PreRecorded/v1/Paragraph.cs
+++ b/Deepgram/Models/PreRecorded/v1/Paragraph.cs
@@ -1,6 +1,4 @@
-using Deepgram.Models.Shared.v1;
-
-namespace Deepgram.Models.PreRecorded.v1;
+namespace Deepgram.Models.PreRecorded.v1;
 
 public record Paragraph
 {
diff --git a/Deepgram/Models/PreRecorded/v1/PrerecordedSchema.cs b/Deepgram/Models/PreRecorded/v1/PrerecordedSchema.cs
index 4f1b7d9b..8a728762 100644
--- a/Deepgram/Models/PreRecorded/v1/PrerecordedSchema.cs
+++ b/Deepgram/Models/PreRecorded/v1/PrerecordedSchema.cs
@@ -1,10 +1,190 @@
-using Deepgram.Models.Shared.v1;
+namespace Deepgram.Models.PreRecorded.v1;
 
-namespace Deepgram.Models.PreRecorded.v1;
-
-public class PrerecordedSchema : TranscriptionSchema
+public class PrerecordedSchema
 {
 
+    /// <summary>
+    /// Number of transcripts to return per request
+    /// <see href="https://developers.deepgram.com/reference/pre-recorded"/>
+    /// Default is 1
+    /// </summary>
+    [JsonPropertyName("alternatives")]
+    public int? Alternatives { get; set; }
+
+    /// <summary>
+    /// CallBack allows you to have your submitted audio processed asynchronously.
+    /// <see href="https://developers.deepgram.com/docs/callback">
+    /// default is null
+    /// </summary>
+    [JsonPropertyName("callback")]
+    public string? CallBack { get; set; }
+
+    /// <summary>
+    /// Enables callback method
+    /// </summary>
+    [JsonPropertyName("callback_method")]
+    public bool? CallbackMethod { get; set; }
+
+    ///// <summary>
+    ///// Optional. A custom intent you want the model to detect within your input audio if present. Submit up to 100.
+    ///// </summary>
+    //[JsonPropertyName("custom_intent")]
+    //public string CustomIntent { get; set; }
+
+    ///// <summary>
+    ///// Optional. Sets how the model will interpret strings submitted to the custom_intent param. When "strict", the model will only return intents submitted using the custom_intent param. When "extended", the model will return it's own detected intents in addition those submitted using the custom_intents param.
+    ///// </summary>
+    //[JsonPropertyName("custom_intent_mode")]
+    //public string CustomIntentMode { get; set; }
+
+
+    /// <summary>
+    /// Diarize recognizes speaker changes and assigns a speaker to each word in the transcript. 
+    /// <see href="https://developers.deepgram.com/docs/diarization">
+    /// default is false
+    /// </summary>
+    [JsonPropertyName("diarize")]
+    public bool? Diarize { get; set; }
+
+    // <summary>
+    /// <see href="https://developers.deepgram.com/docs/diarization">
+    /// default is null, only applies if Diarize is set to true
+    /// </summary>
+    [JsonPropertyName("diarize_version")]
+    public string? DiarizeVersion { get; set; }
+
+    /// <summary>
+    /// Deepgram’s Extra Metadata feature allows you to attach arbitrary key-value pairs to your API requests that are attached to the API response for usage in downstream processing.
+    /// Extra metadata is limited to 2048 characters per key-value pair.
+    /// <see href="https://developers.deepgram.com/docs/extra-metadata"/>
+    /// </summary>
+    [JsonPropertyName("extra")]
+    public Dictionary<string, string> Extra { get; set; }
+
+
+    /// <summary>
+    /// Whether to include words like "uh" and "um" in transcription output. 
+    ///<see href="https://developers.deepgram.com/reference/pre-recorded"/>
+    /// </summary>
+    [JsonPropertyName("filler_words")]
+    public bool? FillerWords { get; set; }
+
+    ///// <summary>
+    ///// Enables intent recognition
+    ///// </summary>
+    //[JsonPropertyName("intents")]
+    //public bool? Intents { get; set; }
+
+    /// <summary>
+    /// Keywords can boost or suppress specialized terminology.
+    /// <see href="https://developers.deepgram.com/docs/keywords">
+    /// </summary>
+    [JsonPropertyName("keywords")]
+    public List<string>? Keywords { get; set; }
+
+    /// <summary>
+    /// Primary spoken language of submitted audio 
+    /// <see href="https://developers.deepgram.com/docs/language">
+    /// default value is 'en' 
+    /// </summary>
+    [JsonPropertyName("language")]
+    public string? Language { get; set; }
+
+    /// <summary>
+    /// AI model used to process submitted audio
+    /// <see href="https://developers.deepgram.com/docs/model">
+    /// </summary>
+    [JsonPropertyName("model")]
+    public string? Model { get; set; }
+
+    /// <summary>
+    /// Multichannel transcribes each channel in submitted audio independently. 
+    /// <see href="https://developers.deepgram.com/docs/multichannel">
+    /// </summary>
+    [JsonPropertyName("multichannel")]
+    public bool? MultiChannel { get; set; }
+
+
+    /// <summary>
+    /// Profanity Filter looks for recognized profanity and converts it to the nearest recognized 
+    /// non-profane word or removes it from the transcript completely.
+    /// <see href="https://developers.deepgram.com/docs/profanity-filter">
+    /// for use with base model tier only
+    /// </summary>
+    [JsonPropertyName("profanity_filter")]
+    public bool? ProfanityFilter { get; set; }
+
+    /// <summary>
+    /// Adds punctuation and capitalization to transcript
+    /// <see href="https://developers.deepgram.com/docs/punctuation">
+    /// </summary>
+    [JsonPropertyName("punctuate")]
+    public bool? Punctuate { get; set; }
+
+    /// <summary>
+    ///  Indicates whether to redact sensitive information, replacing redacted content with asterisks (*). Can send multiple instances in query string (for example, redact=pci&redact=numbers).
+    ///  <see href="https://developers.deepgram.com/docs/redaction">
+    ///  default is List<string>("false") 
+    /// </summary>
+    [JsonPropertyName("redact")]
+    public List<string>? Redact { get; set; }
+
+    /// <summary>
+    /// Find and Replace searches for terms or phrases in submitted audio and replaces them.
+    /// <see href="https://developers.deepgram.com/docs/find-and-replace">
+    /// default is null
+    /// </summary>
+    [JsonPropertyName("replace")]
+    public List<string>? Replace { get; set; }
+
+    /// <summary>
+    /// Search searches for terms or phrases in submitted audio. 
+    /// <see href="https://developers.deepgram.com/docs/search">
+    /// default is null
+    /// </summary>
+    [JsonPropertyName("search")]
+    public List<string>? Search { get; set; }
+
+    ///// <summary>
+    ///// Enables sentiment analysis false by default
+    ///// </summary>
+    //[JsonPropertyName("sentiment")]
+    //public bool? Sentiment { get; set; }
+
+    //[JsonPropertyName("sentiment_threshold")]
+    //public double? SentimentThreshold { get; set; }
+
+    /// <summary>
+    /// Smart Format formats transcripts to improve readability. 
+    /// <see href="https://developers.deepgram.com/docs/smart-format">
+    /// </summary>
+    [JsonPropertyName("smart_format")]
+    public bool? SmartFormat { get; set; }
+
+    /// <summary>
+    /// Tagging allows you to label your requests with one or more tags in a list,for the purpose of identification during usage reporting.
+    /// <see href="https://developers.deepgram.com/docs/tagging">
+    /// Default is a null 
+    /// </summary>
+    [JsonPropertyName("tag")]
+    public List<string>? Tag { get; set; }
+
+    ///// <summary>
+    /////  Level of model you would like to use in your request.
+    /////  <see href="https://developers.deepgram.com/docs/model">   
+    ///// </summary>
+    //[JsonPropertyName("tier")]
+    //[Obsolete("Use Model with joint model syntax https://developers.deepgram.com/docs/models-languages-overview")]
+    //public string? Tier { get; set; }
+
+    /// <summary>
+    /// Version of the model to use.
+    /// <see href="https://developers.deepgram.com/docs/version">
+    /// default value is "latest"
+    /// </summary>
+    [JsonPropertyName("version")]
+    public string? Version { get; set; }
+
     /// <summary>
     /// Entity Detection identifies and extracts key entities from content in submitted audio
     /// <see href="https://developers.deepgram.com/docs/detect-entities">
diff --git a/Deepgram/Models/PreRecorded/v1/Results.cs b/Deepgram/Models/PreRecorded/v1/Results.cs
index 6acdfed6..d9137f23 100644
--- a/Deepgram/Models/PreRecorded/v1/Results.cs
+++ b/Deepgram/Models/PreRecorded/v1/Results.cs
@@ -1,6 +1,4 @@
-using Deepgram.Models.Shared.v1;
-
-namespace Deepgram.Models.PreRecorded.v1;
+namespace Deepgram.Models.PreRecorded.v1;
 
 public record Results
 {
diff --git a/Deepgram/Models/PreRecorded/v1/Segment.cs b/Deepgram/Models/PreRecorded/v1/Segment.cs
new file mode 100644
index 00000000..d91a2f18
--- /dev/null
+++ b/Deepgram/Models/PreRecorded/v1/Segment.cs
@@ -0,0 +1,19 @@
+namespace Deepgram.Models.PreRecorded.v1;
+
+public class Segment
+{
+    [JsonPropertyName("text")]
+    public string Text { get; set; }
+
+    [JsonPropertyName("start_word")]
+    public int? StartWord { get; set; }
+
+    [JsonPropertyName("end_word")]
+    public int? EndWord { get; set; }
+
+    [JsonPropertyName("sentiment")]
+    public string Sentiment { get; set; }
+
+    [JsonPropertyName("sentiment_score")]
+    public double? SentimentScore { get; set; }
+}
diff --git a/Deepgram/Models/PreRecorded/v1/Sentence.cs b/Deepgram/Models/PreRecorded/v1/Sentence.cs
index 8fabc366..f2dc471a 100644
--- a/Deepgram/Models/PreRecorded/v1/Sentence.cs
+++ b/Deepgram/Models/PreRecorded/v1/Sentence.cs
@@ -1,6 +1,4 @@
-using Deepgram.Models.Shared.v1;
-
-namespace Deepgram.Models.PreRecorded.v1;
+namespace Deepgram.Models.PreRecorded.v1;
 
 public record Sentence
 {
diff --git a/Deepgram/Models/PreRecorded/v1/SentimentGroup.cs b/Deepgram/Models/PreRecorded/v1/SentimentGroup.cs
new file mode 100644
index 00000000..5d468ddf
--- /dev/null
+++ b/Deepgram/Models/PreRecorded/v1/SentimentGroup.cs
@@ -0,0 +1,30 @@
+namespace Deepgram.Models.PreRecorded.v1;
+
+public class SentimentGroup
+{
+
+    [JsonPropertyName("sentiment")]
+    public string Sentiment { get; set; }
+
+
+    [JsonPropertyName("sentiment_score")]
+    public double? SentimentScore { get; set; }
+
+
+    [JsonPropertyName("start_time")]
+    public double? StartTime { get; set; }
+
+
+    [JsonPropertyName("end_time")]
+    public double? EndTime { get; set; }
+
+
+    [JsonPropertyName("segments")]
+    public List<Segment> Segments { get; } = [];
+
+
+    [JsonPropertyName("average")]
+    public Average Average { get; set; }
+}
+
+
diff --git a/Deepgram/Models/PreRecorded/v1/SentimentInfo.cs b/Deepgram/Models/PreRecorded/v1/SentimentInfo.cs
new file mode 100644
index 00000000..96ee7301
--- /dev/null
+++ b/Deepgram/Models/PreRecorded/v1/SentimentInfo.cs
@@ -0,0 +1,18 @@
+namespace Deepgram.Models.PreRecorded.v1;
+
+public class SentimentInfo
+{
+
+    [JsonPropertyName("model_uuid")]
+    public string ModelUuid { get; set; }
+
+
+    [JsonPropertyName("input_tokens")]
+    public int? InputTokens { get; set; }
+
+
+    [JsonPropertyName("output_tokens")]
+    public int? OutputTokens { get; set; }
+}
+
+
diff --git a/Deepgram/Models/PreRecorded/v1/SentimentSegment.cs b/Deepgram/Models/PreRecorded/v1/SentimentSegment.cs
new file mode 100644
index 00000000..525f3ca7
--- /dev/null
+++ b/Deepgram/Models/PreRecorded/v1/SentimentSegment.cs
@@ -0,0 +1,26 @@
+namespace Deepgram.Models.PreRecorded.v1;
+
+public class SentimentSegment
+{
+
+    [JsonPropertyName("sentiment")]
+    public string Sentiment { get; set; }
+
+
+    [JsonPropertyName("confidence")]
+    public double? Confidence { get; set; }
+
+
+    [JsonPropertyName("text")]
+    public string Text { get; set; }
+
+
+    [JsonPropertyName("start_word")]
+    public int? StartWord { get; set; }
+
+
+    [JsonPropertyName("end_word")]
+    public int? EndWord { get; set; }
+}
+
+
diff --git a/Deepgram/Models/PreRecorded/v1/Sentiments.cs b/Deepgram/Models/PreRecorded/v1/Sentiments.cs
new file mode 100644
index 00000000..cfaf7b33
--- /dev/null
+++ b/Deepgram/Models/PreRecorded/v1/Sentiments.cs
@@ -0,0 +1,30 @@
+namespace Deepgram.Models.PreRecorded.v1;
+
+public record Sentiments
+{
+
+    [JsonPropertyName("sentiment")]
+    public string Sentiment { get; set; }
+
+
+    [JsonPropertyName("sentiment_score")]
+    public double? SentimentScore { get; set; }
+
+
+    [JsonPropertyName("start_time")]
+    public double? StartTime { get; set; }
+
+
+    [JsonPropertyName("end_time")]
+    public double? EndTime { get; set; }
+
+
+    [JsonPropertyName("segments")]
+    public List<Segment> Segments { get; } = [];
+
+
+    [JsonPropertyName("average")]
+    public Average Average { get; set; }
+}
+
+
diff --git a/Deepgram/Models/PreRecorded/v1/SyncPrerecordedResponse.cs b/Deepgram/Models/PreRecorded/v1/SyncResponse.cs
similarity index 98%
rename from Deepgram/Models/PreRecorded/v1/SyncPrerecordedResponse.cs
rename to Deepgram/Models/PreRecorded/v1/SyncResponse.cs
index e5c75c8e..7fc295e9 100644
--- a/Deepgram/Models/PreRecorded/v1/SyncPrerecordedResponse.cs
+++ b/Deepgram/Models/PreRecorded/v1/SyncResponse.cs
@@ -1,6 +1,6 @@
 namespace Deepgram.Models.PreRecorded.v1;
 
-public record SyncPrerecordedResponse
+public record SyncResponse
 {
     /// <summary>
     /// Metadata of response <see cref="Metadata"/>
diff --git a/Deepgram/Models/PreRecorded/v1/Utterance.cs b/Deepgram/Models/PreRecorded/v1/Utterance.cs
index d1d79865..6d2a2096 100644
--- a/Deepgram/Models/PreRecorded/v1/Utterance.cs
+++ b/Deepgram/Models/PreRecorded/v1/Utterance.cs
@@ -1,6 +1,4 @@
-using Deepgram.Models.Shared.v1;
-
-namespace Deepgram.Models.PreRecorded.v1;
+namespace Deepgram.Models.PreRecorded.v1;
 
 public record Utterance
 {
diff --git a/Deepgram/Models/Shared/v1/TranscriptionSchema.cs b/Deepgram/Models/Shared/v1/TranscriptionSchema.cs
deleted file mode 100644
index a010a87e..00000000
--- a/Deepgram/Models/Shared/v1/TranscriptionSchema.cs
+++ /dev/null
@@ -1,186 +0,0 @@
-namespace Deepgram.Models.Shared.v1;
-public class TranscriptionSchema
-{
-
-    /// <summary>
-    /// Number of transcripts to return per request
-    /// <see href="https://developers.deepgram.com/reference/pre-recorded"/>
-    /// Default is 1
-    /// </summary>
-    [JsonPropertyName("alternatives")]
-    public int? Alternatives { get; set; }
-
-    /// <summary>
-    /// CallBack allows you to have your submitted audio processed asynchronously.
-    /// <see href="https://developers.deepgram.com/docs/callback">
-    /// default is null
-    /// </summary>
-    [JsonPropertyName("callback")]
-    public string? CallBack { get; set; }
-
-    /// <summary>
-    /// Enables callback method
-    /// </summary>
-    [JsonPropertyName("callback_method")]
-    public bool? CallbackMethod { get; set; }
-
-    ///// <summary>
-    ///// Optional. A custom intent you want the model to detect within your input audio if present. Submit up to 100.
-    ///// </summary>
-    //[JsonPropertyName("custom_intent")]
-    //public string CustomIntent { get; set; }
-
-    ///// <summary>
-    ///// Optional. Sets how the model will interpret strings submitted to the custom_intent param. When "strict", the model will only return intents submitted using the custom_intent param. When "extended", the model will return it's own detected intents in addition those submitted using the custom_intents param.
-    ///// </summary>
-    //[JsonPropertyName("custom_intent_mode")]
-    //public string CustomIntentMode { get; set; }
-
-
-    /// <summary>
-    /// Diarize recognizes speaker changes and assigns a speaker to each word in the transcript. 
-    /// <see href="https://developers.deepgram.com/docs/diarization">
-    /// default is false
-    /// </summary>
-    [JsonPropertyName("diarize")]
-    public bool? Diarize { get; set; }
-
-    // <summary>
-    /// <see href="https://developers.deepgram.com/docs/diarization">
-    /// default is null, only applies if Diarize is set to true
-    /// </summary>
-    [JsonPropertyName("diarize_version")]
-    public string? DiarizeVersion { get; set; }
-
-    /// <summary>
-    /// Deepgram’s Extra Metadata feature allows you to attach arbitrary key-value pairs to your API requests that are attached to the API response for usage in downstream processing.
-    /// Extra metadata is limited to 2048 characters per key-value pair.
-    /// <see href="https://developers.deepgram.com/docs/extra-metadata"/>
-    /// </summary>
-    [JsonPropertyName("extra")]
-    public Dictionary<string, string> Extra { get; set; }
-
-
-    /// <summary>
-    /// Whether to include words like "uh" and "um" in transcription output. 
-    ///<see href="https://developers.deepgram.com/reference/pre-recorded"/>
-    /// </summary>
-    [JsonPropertyName("filler_words")]
-    public bool? FillerWords { get; set; }
-
-    ///// <summary>
-    ///// Enables intent recognition
-    ///// </summary>
-    //[JsonPropertyName("intents")]
-    //public bool? Intents { get; set; }
-
-    /// <summary>
-    /// Keywords can boost or suppress specialized terminology.
-    /// <see href="https://developers.deepgram.com/docs/keywords">
-    /// </summary>
-    [JsonPropertyName("keywords")]
-    public List<string>? Keywords { get; set; }
-
-    /// <summary>
-    /// Primary spoken language of submitted audio 
-    /// <see href="https://developers.deepgram.com/docs/language">
-    /// default value is 'en' 
-    /// </summary>
-    [JsonPropertyName("language")]
-    public string? Language { get; set; }
-
-    /// <summary>
-    /// AI model used to process submitted audio
-    /// <see href="https://developers.deepgram.com/docs/model">
-    /// </summary>
-    [JsonPropertyName("model")]
-    public string? Model { get; set; }
-
-    /// <summary>
-    /// Multichannel transcribes each channel in submitted audio independently. 
-    /// <see href="https://developers.deepgram.com/docs/multichannel">
-    /// </summary>
-    [JsonPropertyName("multichannel")]
-    public bool? MultiChannel { get; set; }
-
-
-    /// <summary>
-    /// Profanity Filter looks for recognized profanity and converts it to the nearest recognized 
-    /// non-profane word or removes it from the transcript completely.
-    /// <see href="https://developers.deepgram.com/docs/profanity-filter">
-    /// for use with base model tier only
-    /// </summary>
-    [JsonPropertyName("profanity_filter")]
-    public bool? ProfanityFilter { get; set; }
-
-    /// <summary>
-    /// Adds punctuation and capitalization to transcript
-    /// <see href="https://developers.deepgram.com/docs/punctuation">
-    /// </summary>
-    [JsonPropertyName("punctuate")]
-    public bool? Punctuate { get; set; }
-
-    /// <summary>
-    ///  Indicates whether to redact sensitive information, replacing redacted content with asterisks (*). Can send multiple instances in query string (for example, redact=pci&redact=numbers).
-    ///  <see href="https://developers.deepgram.com/docs/redaction">
-    ///  default is List<string>("false") 
-    /// </summary>
-    [JsonPropertyName("redact")]
-    public List<string>? Redact { get; set; }
-
-    /// <summary>
-    /// Find and Replace searches for terms or phrases in submitted audio and replaces them.
-    /// <see href="https://developers.deepgram.com/docs/find-and-replace">
-    /// default is null
-    /// </summary>
-    [JsonPropertyName("replace")]
-    public List<string>? Replace { get; set; }
-
-    /// <summary>
-    /// Search searches for terms or phrases in submitted audio. 
-    /// <see href="https://developers.deepgram.com/docs/search">
-    /// default is null
-    /// </summary>
-    [JsonPropertyName("search")]
-    public List<string>? Search { get; set; }
-
-    ///// <summary>
-    ///// Enables sentiment analysis false by default
-    ///// </summary>
-    //[JsonPropertyName("sentiment")]
-    //public bool? Sentiment { get; set; }
-
-    //[JsonPropertyName("sentiment_threshold")]
-    //public double? SentimentThreshold { get; set; }
-
-    /// <summary>
-    /// Smart Format formats transcripts to improve readability. 
-    /// <see href="https://developers.deepgram.com/docs/smart-format">
-    /// </summary>
-    [JsonPropertyName("smart_format")]
-    public bool? SmartFormat { get; set; }
-
-    /// <summary>
-    /// Tagging allows you to label your requests with one or more tags in a list,for the purpose of identification during usage reporting.
-    /// <see href="https://developers.deepgram.com/docs/tagging">
-    /// Default is a null 
-    /// </summary>
-    [JsonPropertyName("tag")]
-    public List<string>? Tag { get; set; }
-
-    ///// <summary>
-    /////  Level of model you would like to use in your request.
-    /////  <see href="https://developers.deepgram.com/docs/model">   
-    ///// </summary>
-    //[JsonPropertyName("tier")]
-    //[Obsolete("Use Model with joint model syntax https://developers.deepgram.com/docs/models-languages-overview")]
-    //public string? Tier { get; set; }
-
-    /// <summary>
-    /// Version of the model to use.
-    /// <see href="https://developers.deepgram.com/docs/version">
-    /// default value is "latest"
-    /// </summary>
-    [JsonPropertyName("version")]
-    public string? Version { get; set; }
-}
diff --git a/Deepgram/OnPremClient.cs b/Deepgram/OnPremClient.cs
index 58692dac..81182623 100644
--- a/Deepgram/OnPremClient.cs
+++ b/Deepgram/OnPremClient.cs
@@ -1,6 +1,6 @@
 using Deepgram.Models.Manage.v1;
 using Deepgram.Models.OnPrem.v1;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram;
 
@@ -18,18 +18,18 @@ public class OnPremClient(string apiKey, DeepgramClientOptions? deepgramClientOp
     /// get a list of credentials associated with project
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <returns><see cref="ListOnPremCredentialsResponse"/></returns>
-    public async Task<ListOnPremCredentialsResponse> ListCredentials(string projectId, CancellationToken cancellationToken = default) =>
-        await GetAsync<ListOnPremCredentialsResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.ONPREM}", cancellationToken);
+    /// <returns><see cref="CredentialsResponse"/></returns>
+    public async Task<CredentialsResponse> ListCredentials(string projectId, CancellationToken cancellationToken = default) =>
+        await GetAsync<CredentialsResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.ONPREM}", cancellationToken);
 
     /// <summary>
     /// Get credentials for the project that is associated with credential ID
     /// </summary>
     /// <param name="projectId">Id of project</param>
     /// <param name="credentialsId">Id of credentials</param>
-    /// <returns><see cref="OnPremCredentialsResponse"/></returns>
-    public async Task<OnPremCredentialsResponse> GetCredentials(string projectId, string credentialsId, CancellationToken cancellationToken = default) =>
-        await GetAsync<OnPremCredentialsResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.ONPREM}/{credentialsId}", cancellationToken);
+    /// <returns><see cref="CredentialResponse"/></returns>
+    public async Task<CredentialResponse> GetCredentials(string projectId, string credentialsId, CancellationToken cancellationToken = default) =>
+        await GetAsync<CredentialResponse>($"{UriSegments.PROJECTS}/{projectId}/{UriSegments.ONPREM}/{credentialsId}", cancellationToken);
 
     /// <summary>
     /// Remove credentials in the project associated with the credentials ID
@@ -44,10 +44,10 @@ public async Task<MessageResponse> DeleteCredentials(string projectId, string cr
     /// Create credentials for the associated projects
     /// </summary>
     /// <param name="projectId">Id of project</param>
-    /// <param name="createOnPremCredentialsSchema"><see cref="CreateOnPremCredentialsSchema"/> for credentials to be created</param>
-    /// <returns><see cref="OnPremCredentialsResponse"/></returns>
-    public async Task<OnPremCredentialsResponse> CreateCredentials(string projectId, CreateOnPremCredentialsSchema createOnPremCredentialsSchema, CancellationToken cancellationToken = default) =>
-        await PostAsync<OnPremCredentialsResponse>(
+    /// <param name="createOnPremCredentialsSchema"><see cref="CredentialsSchema"/> for credentials to be created</param>
+    /// <returns><see cref="CredentialResponse"/></returns>
+    public async Task<CredentialResponse> CreateCredentials(string projectId, CredentialsSchema createOnPremCredentialsSchema, CancellationToken cancellationToken = default) =>
+        await PostAsync<CredentialResponse>(
             $"{UriSegments.PROJECTS}/{projectId}/{UriSegments.ONPREM}",
             RequestContentUtil.CreatePayload(createOnPremCredentialsSchema), cancellationToken);
 
diff --git a/Deepgram/PrerecordedClient.cs b/Deepgram/PrerecordedClient.cs
index 64d6ae9c..a6ed6b44 100644
--- a/Deepgram/PrerecordedClient.cs
+++ b/Deepgram/PrerecordedClient.cs
@@ -1,5 +1,5 @@
 using Deepgram.Models.PreRecorded.v1;
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram;
 
@@ -18,12 +18,12 @@ public class PrerecordedClient(string apiKey, DeepgramClientOptions? deepgramCli
     /// </summary>
     /// <param name="source">Url to the file that is to be transcribed <see cref="UrlSource"></param>
     /// <param name="prerecordedSchema">Options for the transcription <see cref="PrerecordedSchema"/></param>
-    /// <returns><see cref="SyncPrerecordedResponse"/></returns>
-    public async Task<SyncPrerecordedResponse> TranscribeUrl(UrlSource source, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
+    /// <returns><see cref="SyncResponse"/></returns>
+    public async Task<SyncResponse> TranscribeUrl(UrlSource source, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
     {
         VerifyNoCallBack(nameof(TranscribeUrl), prerecordedSchema);
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
-        return await PostAsync<SyncPrerecordedResponse>(
+        return await PostAsync<SyncResponse>(
             $"{UriSegments.LISTEN}?{stringedOptions}",
             RequestContentUtil.CreatePayload(source), cancellationToken);
     }
@@ -32,14 +32,14 @@ public async Task<SyncPrerecordedResponse> TranscribeUrl(UrlSource source, Prere
     /// </summary>
     /// <param name="source">file is the form of a byte[]</param>
     /// <param name="prerecordedSchema">Options for the transcription <see cref="PrerecordedSchema"/></param>
-    /// <returns><see cref="SyncPrerecordedResponse"/></returns>
-    public async Task<SyncPrerecordedResponse> TranscribeFile(byte[] source, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
+    /// <returns><see cref="SyncResponse"/></returns>
+    public async Task<SyncResponse> TranscribeFile(byte[] source, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
     {
         VerifyNoCallBack(nameof(TranscribeFile), prerecordedSchema);
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
         var stream = new MemoryStream();
         stream.Write(source, 0, source.Length);
-        return await PostAsync<SyncPrerecordedResponse>(
+        return await PostAsync<SyncResponse>(
             $"{UriSegments.LISTEN}?{stringedOptions}",
             RequestContentUtil.CreateStreamPayload(stream), cancellationToken);
     }
@@ -49,12 +49,12 @@ public async Task<SyncPrerecordedResponse> TranscribeFile(byte[] source, Prereco
     /// </summary>
     /// <param name="source">file is the form of a stream <see cref="Stream"/></param>
     /// <param name="prerecordedSchema">Options for the transcription <see cref="PrerecordedSchema"/></param>
-    /// <returns><see cref="SyncPrerecordedResponse"/></returns>
-    public async Task<SyncPrerecordedResponse> TranscribeFile(Stream source, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
+    /// <returns><see cref="SyncResponse"/></returns>
+    public async Task<SyncResponse> TranscribeFile(Stream source, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
     {
         VerifyNoCallBack(nameof(TranscribeFile), prerecordedSchema);
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
-        return await PostAsync<SyncPrerecordedResponse>(
+        return await PostAsync<SyncResponse>(
             $"{UriSegments.LISTEN}?{stringedOptions}",
             RequestContentUtil.CreateStreamPayload(source), cancellationToken);
     }
@@ -68,8 +68,8 @@ public async Task<SyncPrerecordedResponse> TranscribeFile(Stream source, Prereco
     /// <param name="source">file is the form of a byte[]</param>  
     /// <param name="callBack">CallBack url</param>    
     /// <param name="prerecordedSchema">Options for the transcription<see cref="PrerecordedSchema"></param>
-    /// <returns><see cref="AsyncPrerecordedResponse"/></returns>
-    public async Task<AsyncPrerecordedResponse> TranscribeFileCallBack(byte[] source, string? callBack, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
+    /// <returns><see cref="AsyncResponse"/></returns>
+    public async Task<AsyncResponse> TranscribeFileCallBack(byte[] source, string? callBack, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
     {
         VerifyOneCallBackSet(nameof(TranscribeFileCallBack), callBack, prerecordedSchema);
 
@@ -78,7 +78,7 @@ public async Task<AsyncPrerecordedResponse> TranscribeFileCallBack(byte[] source
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
         var stream = new MemoryStream();
         stream.Write(source, 0, source.Length);
-        return await PostAsync<AsyncPrerecordedResponse>(
+        return await PostAsync<AsyncResponse>(
             $"{UriSegments.LISTEN}?{stringedOptions}",
             RequestContentUtil.CreateStreamPayload(stream), cancellationToken);
     }
@@ -89,14 +89,14 @@ public async Task<AsyncPrerecordedResponse> TranscribeFileCallBack(byte[] source
     /// <param name="source">file is the form of a stream <see cref="Stream"></param>  
     /// <param name="callBack">CallBack url</param>    
     /// <param name="prerecordedSchema">Options for the transcription<see cref="PrerecordedSchema"></param>
-    /// <returns><see cref="AsyncPrerecordedResponse"/></returns>
-    public async Task<AsyncPrerecordedResponse> TranscribeFileCallBack(Stream source, string? callBack, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
+    /// <returns><see cref="AsyncResponse"/></returns>
+    public async Task<AsyncResponse> TranscribeFileCallBack(Stream source, string? callBack, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
     {
         VerifyOneCallBackSet(nameof(TranscribeFileCallBack), callBack, prerecordedSchema);
         if (callBack != null)
             prerecordedSchema.CallBack = callBack;
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
-        return await PostAsync<AsyncPrerecordedResponse>(
+        return await PostAsync<AsyncResponse>(
             $"{UriSegments.LISTEN}?{stringedOptions}",
             RequestContentUtil.CreateStreamPayload(source), cancellationToken);
     }
@@ -107,15 +107,15 @@ public async Task<AsyncPrerecordedResponse> TranscribeFileCallBack(Stream source
     /// <param name="source">Url to the file that is to be transcribed <see cref="UrlSource"/></param>
     /// <param name="callBack">CallBack url</param>    
     /// <param name="prerecordedSchema">Options for the transcription<see cref="PrerecordedSchema"></param>
-    /// <returns><see cref="AsyncPrerecordedResponse"/></returns>
-    public async Task<AsyncPrerecordedResponse> TranscribeUrlCallBack(UrlSource source, string? callBack, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
+    /// <returns><see cref="AsyncResponse"/></returns>
+    public async Task<AsyncResponse> TranscribeUrlCallBack(UrlSource source, string? callBack, PrerecordedSchema? prerecordedSchema, CancellationToken cancellationToken = default)
     {
         VerifyOneCallBackSet(nameof(TranscribeUrlCallBack), callBack, prerecordedSchema);
 
         if (callBack != null)
             prerecordedSchema.CallBack = callBack;
         var stringedOptions = QueryParameterUtil.GetParameters(prerecordedSchema);
-        return await PostAsync<AsyncPrerecordedResponse>(
+        return await PostAsync<AsyncResponse>(
             $"{UriSegments.LISTEN}?{stringedOptions}",
             RequestContentUtil.CreatePayload(source), cancellationToken);
     }
diff --git a/Deepgram/README.md b/Deepgram/README.md
index 951cd9e0..65b4146d 100644
--- a/Deepgram/README.md
+++ b/Deepgram/README.md
@@ -229,7 +229,7 @@ var deepgramClient = new LiveClient(apiKey);
 using (var deepgramLive = deepgramClient.CreateLiveTranscriptionClient())
 {
     
-    deepgramLive.LiveResponseReceived += LiveResponseReceived;
+    deepgramLive.EventResponseReceived += EventResponseReceived;
 
     // Connection opened so start sending audio.
     async void HandleConnectionOpened(object? sender, ConnectionOpenEventArgs e)
@@ -253,7 +253,7 @@ using (var deepgramLive = deepgramClient.CreateLiveTranscriptionClient())
         await deepgramLive.FinishAsync();
     }
 
-    private async void HandleLiveResponseReceived(object? sender, LiveResponseReceivedEventArgs e)
+    private async void HandleEventResponseReceived(object? sender, ResponseReceivedEventArgs e)
     {
         if (e.Response.Error is not null)
         {
@@ -344,7 +344,7 @@ var result = await manageClient.GetProject(projectId);
 Update a project.
 
 ```csharp
-var updateProjectSchema = new UpdateProjectSchema()
+var updateProjectSchema = new ProjectSchema()
 {
     Company = "Acme",
     Name = "Mega Speech inc"
@@ -353,7 +353,7 @@ var result = await manageClient.UpdateProjectAsync(projectid,updateProjectSchema
 
 ```
 
-**UpdateProjectSchema Type**
+**ProjectSchema Type**
 
 | Property Name | Type   |                       Description                        |
 | ------------- | :----- | :------------------------------------------------------: |
@@ -423,7 +423,7 @@ var result = await manageClient.CreateProjectKey(projectId,createProjectKeyWithE
 
 [See our API reference for more info](https://developers.deepgram.com/reference/create-key).
 
-### CreateProjectKeySchema
+### KeySchema
 | Property              | Type         | Required |              Description        |
 | -------------         | :-------     | :--------|:-------------------------------:|
 | Scopes                | List<string> |  *       | scopes for key                  |
@@ -511,12 +511,12 @@ var result = await manageClient.GetProjectInvitesAsync(projectId);
 Sends an invitation to the provided email address.
 
 ```csharp
-var sendProjectInviteSchema = new SendProjectInviteSchema()
+var inviteSchema = new InviteSchema()
 {
     Email = "awesome@person.com",
     Scope = "fab"
 }
-var result = manageClient.SendProjectInviteAsync(projectId,sendProjectInviteSchema)
+var result = manageClient.SendProjectInviteAsync(projectId,inviteSchema)
 ```
 
 [See our API reference for more info](https://developers.deepgram.com/reference/send-invites).
@@ -541,14 +541,14 @@ Removes the specified invitation from the project.
 Retrieves all requests associated with the provided projectId based on the provided options.
 
 ```csharp
-var getProjectUsageRequestsSchema = new GetProjectUsageRequestsSchema ()
+var UsageRequestsSchema = new UsageRequestsSchema ()
 {
      Start = DateTime.Now.AddDays(-7);
 };
-var result = await manageClient.ListAllRequestsAsync(projectId,getProjectUsageRequestsSchema);
+var result = await manageClient.ListAllRequestsAsync(projectId,UsageRequestsSchema);
 ```
 
-### GetProjectUsageRequestsSchema
+### UsageRequestsSchema
 
 | Property      | Type     |              Description               |
 | ------------- | :------- | :------------------------------------: |
@@ -613,14 +613,14 @@ var result = await manageClient.GetProjectUsageSummaryAsync(projectId,getProject
 Lists the features, models, tags, languages, and processing method used for requests in the specified project.
 
 ```csharp
-var getProjectUsageFieldsSchema = new GetProjectUsageFieldsSchema()
+var getProjectUsageFieldsSchema = new UsageFieldsSchema()
 {
     Start = Datetime.Now
 }
 var result = await manageClient.GetProjectUsageFieldsAsync(projectId,getProjectUsageFieldsSchema);
 ```
 
-### GetProjectUsageFieldsSchema
+### UsageFieldsSchema
 
 | Property      | Value    |              Description               |
 | ------------- | :------- | :------------------------------------: |
@@ -666,7 +666,7 @@ var result = onPremClient.DeleteCredentialsASync(projectId,credentialsId);
 
 ## Create Credentials
 ```csharp
-var createOnPremCredentialsSchema = new CreateOnPremCredentialsSchema()
+var createOnPremCredentialsSchema = new CredentialsSchema()
  {
     Comment = "my new credentials",
     Scopes = new  List<string>{"team fab"},
@@ -675,7 +675,7 @@ var createOnPremCredentialsSchema = new CreateOnPremCredentialsSchema()
 var result = onPremClientCreateCredentialsAsync(string projectId,  createOnPremCredentialsSchema)
 ```
 
-### CreateOnPremCredentialsSchema
+### CredentialsSchema
 
 | Property      | Value     |              Description               |
 | ------------- | :-------  | :------------------------------------: |
diff --git a/Deepgram/ReadClient.cs b/Deepgram/ReadClient.cs
index 25440b21..d7306ee4 100644
--- a/Deepgram/ReadClient.cs
+++ b/Deepgram/ReadClient.cs
@@ -1,4 +1,4 @@
-using Deepgram.Models.Shared.v1;
+using Deepgram.Models.Authenticate.v1;
 
 namespace Deepgram;
 
diff --git a/Deepgram/TodoAndChanges.md b/Deepgram/TodoAndChanges.md
index 6ab73cd9..693a7861 100644
--- a/Deepgram/TodoAndChanges.md
+++ b/Deepgram/TodoAndChanges.md
@@ -3,8 +3,8 @@
 ## Deepgram
 - Live client change event args to callback
 - <del>Live client - when receiving data type of data needs to be check currently the
-    recieve method only expects to recieve LiveTranscriptionResponse but the method 
-    can recieve either LiveTranscriptionResponse or LiveMetadataResponse
+    recieve method only expects to recieve TranscriptionResponse but the method 
+    can recieve either TranscriptionResponse or MetadataResponse
 
     
 
diff --git a/README.md b/README.md
index f5888acf..e1dfd728 100644
--- a/README.md
+++ b/README.md
@@ -335,7 +335,7 @@ var result = await manageClient.GetProject(projectId);
 Update a project.
 
 ```csharp
-var updateProjectSchema = new UpdateProjectSchema()
+var updateProjectSchema = new ProjectSchema()
 {
     Company = "Acme",
     Name = "Mega Speech inc"
@@ -344,7 +344,7 @@ var result = await manageClient.UpdateProjectAsync(projectid,updateProjectSchema
 
 ```
 
-**UpdateProjectSchema Type**
+**ProjectSchema Type**
 
 | Property Name | Type   |                       Description                        |
 | ------------- | :----- | :------------------------------------------------------: |
@@ -414,7 +414,7 @@ var result = await manageClient.CreateProjectKey(projectId,createProjectKeyWithE
 
 [See our API reference for more info](https://developers.deepgram.com/reference/create-key).
 
-#### CreateProjectKeySchema
+#### KeySchema
 | Property              | Type         | Required |              Description        |
 | -------------         | :-------     | :--------|:-------------------------------:|
 | Scopes                | List<string> |  *       | scopes for key                  |
@@ -502,12 +502,12 @@ var result = await manageClient.GetProjectInvitesAsync(projectId);
 Sends an invitation to the provided email address.
 
 ```csharp
-var sendProjectInviteSchema = new SendProjectInviteSchema()
+var inviteSchema = new InviteSchema()
 {
     Email = "awesome@person.com",
     Scope = "fab"
 }
-var result = manageClient.SendProjectInviteAsync(projectId,sendProjectInviteSchema)
+var result = manageClient.SendProjectInviteAsync(projectId,inviteSchema)
 ```
 
 [See our API reference for more info](https://developers.deepgram.com/reference/send-invites).
@@ -532,14 +532,14 @@ Removes the specified invitation from the project.
 Retrieves all requests associated with the provided projectId based on the provided options.
 
 ```csharp
-var getProjectUsageRequestsSchema = new GetProjectUsageRequestsSchema ()
+var UsageRequestsSchema = new UsageRequestsSchema ()
 {
      Start = DateTime.Now.AddDays(-7);
 };
-var result = await manageClient.ListAllRequestsAsync(projectId,getProjectUsageRequestsSchema);
+var result = await manageClient.ListAllRequestsAsync(projectId,UsageRequestsSchema);
 ```
 
-#### GetProjectUsageRequestsSchema
+#### UsageRequestsSchema
 
 | Property      | Type     |              Description               |
 | ------------- | :------- | :------------------------------------: |
@@ -604,14 +604,14 @@ var result = await manageClient.GetProjectUsageSummaryAsync(projectId,getProject
 Lists the features, models, tags, languages, and processing method used for requests in the specified project.
 
 ```csharp
-var getProjectUsageFieldsSchema = new GetProjectUsageFieldsSchema()
+var getProjectUsageFieldsSchema = new UsageFieldsSchema()
 {
     Start = Datetime.Now
 }
 var result = await manageClient.GetProjectUsageFieldsAsync(projectId,getProjectUsageFieldsSchema);
 ```
 
-#### GetProjectUsageFieldsSchema
+#### UsageFieldsSchema
 
 | Property      | Value    |              Description               |
 | ------------- | :------- | :------------------------------------: |
@@ -657,7 +657,7 @@ var result = onPremClient.DeleteCredentialsASync(projectId,credentialsId);
 
 ## Create Credentials
 ```csharp
-var createOnPremCredentialsSchema = new CreateOnPremCredentialsSchema()
+var createOnPremCredentialsSchema = new CredentialsSchema()
  {
     Comment = "my new credentials",
     Scopes = new  List<string>{"team fab"},
@@ -666,7 +666,7 @@ var createOnPremCredentialsSchema = new CreateOnPremCredentialsSchema()
 var result = onPremClientCreateCredentialsAsync(string projectId,  createOnPremCredentialsSchema)
 ```
 
-#### CreateOnPremCredentialsSchema
+#### CredentialsSchema
 
 | Property      | Value     |              Description               |
 | ------------- | :-------  | :------------------------------------: |